/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.3.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

#include <config.h>

#ifdef __clang__
// The Python 3.3 headers have several uses of the C register keyword, which
// result in warnings from clang++ 6.  There's nothing we can really do about
// them, so just suppress them.  This appears to have been addressed in Python
// 3.4 and later.
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-register"
#endif

#include <Python.h>

#ifdef __clang__
# pragma clang diagnostic pop
#endif

/* Override SWIG's standard GIL locking machinery - we want to handle the GIL
 * in a way which also works in sub-interpreters.
 *
 * For Python < 3.7 we can also avoid the overhead of thread locking when the
 * user's code isn't using threads (since 3.7, Python always initialises
 * threads.)
 */
#define SWIG_PYTHON_NO_USE_GIL

static thread_local PyThreadState * swig_pythreadstate = NULL;

inline PyThreadState * swig_pythreadstate_reset() {
    PyThreadState * v = swig_pythreadstate;
    if (v) swig_pythreadstate = NULL;
    return v;
}

inline PyThreadState * swig_pythreadstate_set(PyThreadState * v) {
    PyThreadState * old = swig_pythreadstate;
    swig_pythreadstate = v;
    return old;
}

class XapianSWIG_Python_Thread_Block {
    bool status;
  public:
    XapianSWIG_Python_Thread_Block() : status(false) {
#if PY_VERSION_HEX < 0x03070000
        // Since 3.7, Python initialises the GIL in PyInitialize() so
        // PyEval_ThreadsInitialized() is no longer useful and was
        // deprecated in 3.9.
        if (!PyEval_ThreadsInitialized()) return;
#endif
        PyThreadState* ts = swig_pythreadstate_reset();
        if (ts) {
            status = true;
            PyEval_RestoreThread(ts);
        }
    }
    void end() {
        if (status) {
            if (swig_pythreadstate_set(PyEval_SaveThread()))
                Py_FatalError("swig_pythreadstate set in XapianSWIG_Python_Thread_Block::end()");
            status = false;
        }
    }
    ~XapianSWIG_Python_Thread_Block() { end(); }
};

class XapianSWIG_Python_Thread_Allow {
    bool status;
  public:
    XapianSWIG_Python_Thread_Allow() : status(true) {
#if PY_VERSION_HEX < 0x03070000
        // Since 3.7, Python initialises the GIL in PyInitialize() so
        // PyEval_ThreadsInitialized() is no longer useful and was
        // deprecated in 3.9.
        if (!PyEval_ThreadsInitialized()) {
            status = false;
            return;
        }
#endif
        if (swig_pythreadstate_set(PyEval_SaveThread()))
            Py_FatalError("swig_pythreadstate set in XapianSWIG_Python_Thread_Allow ctor");
    }
    void end() {
        if (status) {
            PyThreadState * ts = swig_pythreadstate_reset();
            if (!ts)
                Py_FatalError("swig_pythreadstate unset in XapianSWIG_Python_Thread_Block::end()");
            PyEval_RestoreThread(ts);
            status = false;
        }
    }
    ~XapianSWIG_Python_Thread_Allow() { end(); }
};

#define SWIG_PYTHON_THREAD_BEGIN_BLOCK   XapianSWIG_Python_Thread_Block _xapian_swig_thread_block
#define SWIG_PYTHON_THREAD_END_BLOCK     _xapian_swig_thread_block.end()
#define SWIG_PYTHON_THREAD_BEGIN_ALLOW   XapianSWIG_Python_Thread_Allow _xapian_swig_thread_allow
#define SWIG_PYTHON_THREAD_END_ALLOW     _xapian_swig_thread_allow.end()



#define SWIG_VERSION 0x040300
#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_THREADS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_FASTPROXY

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NULLPTR nullptr
#else
# define SWIG_NULLPTR NULL
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows returning the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporary objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#endif
}

SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

#ifdef Py_LIMITED_API
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    if (newvalue) {
      SWIG_Py_XDECREF(value);
      PyErr_Restore(type, newvalue, traceback);
    } else {
      PyErr_Restore(type, value, traceback);
    }
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      if PY_VERSION_HEX < 0x03070000
#        define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
#      else
#        define SWIG_PYTHON_INITIALIZE_THREADS
#      endif
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  SWIG_Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  SWIG_Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_Py_DECREF(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
  static char varlink__doc__[] = "Swig var link object";
#ifndef Py_LIMITED_API
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      "swigvarlink",                      /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /*tp_print*/
#else
      (Py_ssize_t)0,                      /*tp_vectorcall_offset*/
#endif
      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) swig_varlink_repr,       /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) swig_varlink_str,        /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      varlink__doc__,                     /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030C0000
      0,                                  /* tp_watched */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)swig_varlink_dealloc },
    { Py_tp_repr, (void *)swig_varlink_repr },
    { Py_tp_getattr, (void *)swig_varlink_getattr },
    { Py_tp_setattr, (void *)swig_varlink_setattr },
    { Py_tp_str, (void *)swig_varlink_str },
    { Py_tp_doc, (void *)varlink__doc__ },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "swigvarlink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  SWIG_Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    SWIG_Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      SWIG_Py_INCREF(obj);
      data->newargs = obj;
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
        data->newargs = PyTuple_New(1);
        if (data->newargs) {
          SWIG_Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          SWIG_Py_DECREF(data->newraw);
          SWIG_Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        SWIG_Py_INCREF(obj);
        data->newargs = obj;
      }
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data)
{
  SWIG_Py_XDECREF(data->klass);
  SWIG_Py_XDECREF(data->newraw);
  SWIG_Py_XDECREF(data->newargs);
  SWIG_Py_XDECREF(data->destroy);
  free(data);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  SWIG_Py_XINCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    PyObject *val = SwigPyObject_long(v);
    if (val) {
      PyObject *ofmt;
      PyTuple_SET_ITEM(args, 0, val);
      ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
        res = PyUnicode_Format(ofmt,args);
#else
        res = PyString_Format(ofmt,args);
#endif
        SWIG_Py_DECREF(ofmt);
      }
    }
    SWIG_Py_DECREF(args);
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      SWIG_Py_DECREF(repr);
      repr = NULL;
    }
  }
  return repr;
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    if (op != Py_EQ && op != Py_NE) {
      SWIG_Py_INCREF(Py_NotImplemented);
      return Py_NotImplemented;
    }
    res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  }
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  if (PyType_IsSubtype(op_type, target_tp))
    return 1;
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
#else
# ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  if (op_type == target_tp)
    return 1;
# ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
# else
  return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
# endif
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

static PyObject* Swig_Capsule_global = NULL;

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        if (tmp) {
          res = SWIG_Python_CallFunctor(destroy, tmp);
        } else {
          res = 0;
        }
        SWIG_Py_XDECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      SWIG_Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
    SWIG_Py_XDECREF(Swig_Capsule_global);
  }
  SWIG_Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
  SWIG_Py_XDECREF(sobj->dict);
#endif
  PyObject_Free(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  SWIG_Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    SWIG_Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        SWIG_Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

static PyMethodDef
swigobject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
#ifndef Py_LIMITED_API
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyObject",                       /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /*tp_print*/
#else
      (Py_ssize_t)0,                        /*tp_vectorcall_offset*/
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_methods,                   /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030C0000
      0,                                    /* tp_watched */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
  }
  return &swigpyobject_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)swigobject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)swigobject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
    sobj->dict = 0;
#endif
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
#ifdef Py_LIMITED_API
  int cmp;
  PyObject *tp_name;
#endif
  PyTypeObject* op_type = Py_TYPE(op);
  if (op_type == SwigPyPacked_TypeOnce())
    return 1;
#ifdef Py_LIMITED_API
  tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
  if (!tp_name)
    return 0;
  cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
  SWIG_Py_DECREF(tp_name);
  return cmp == 0;
#else
  return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
#endif
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_Free(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
#ifndef Py_LIMITED_API
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyPacked",                       /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /*tp_print*/
#else
      (Py_ssize_t)0,                        /*tp_vectorcall_offset*/
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030C0000
      0,                                    /* tp_watched */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
  }
  return &swigpypacked_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)swigpacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    "SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  return (PyTypeObject *)PyType_FromSpec(&spec);
#endif
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_Free((PyObject *)sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	SWIG_Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    SWIG_Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
      res = SWIG_ERROR_RELEASE_NOT_OWNED;
    } else {
      if (own)
        *own = *own | sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
      }
      if (flags & SWIG_POINTER_CLEAR) {
        sobj->ptr = 0;
      }
      res = SWIG_OK;
    }
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            SWIG_Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
#ifndef Py_LIMITED_API
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
    PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
    PyObject *bytes = NULL;
    const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_XDECREF(pystr_doc);
#endif
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      if (newobj) {
        newobj->dict = 0;
      }
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    SWIG_Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
  }
#else
  void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
  if (PyErr_Occurred()) {
    PyErr_Clear();
    type_pointer = (void *)0;
  }
#endif
  return (swig_module_info *) type_pointer;
}


static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
  SWIG_Py_DECREF(SWIG_globals());
  Swig_Globals_global = NULL;
  SWIG_Py_DECREF(SWIG_Python_TypeCache());
  Swig_TypeCache_global = NULL;
  Swig_Capsule_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) {
        PyDict_SetItem(cache, key, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  SWIG_Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  (void) obj;
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
#ifndef Py_LIMITED_API
      /* tp_name is not accessible */
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	PyObject *bytes = NULL;
	const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	SWIG_Py_XDECREF(bytes);
	SWIG_Py_XDECREF(str);
	return;
      }
#endif
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    SWIG_Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) != 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

#ifdef __cplusplus
}
#endif


  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>

#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
#ifndef Py_LIMITED_API
# include "pythread.h"
#else
# if defined(_WIN32)
#   include <windows.h>
# else
#   include <pthread.h>
# endif
#endif
#endif

/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
#define SWIG_PYTHON_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR

namespace Swig {
  class Director;
  SWIGINTERN std::map<void *, Director *>& get_rtdir_map() {
    static std::map<void *, Director *> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void *, Director *>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void *>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void *>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem {
    virtual ~GCItem() {}

    virtual int get_own() const {
      return 0;
    }
  };

  struct GCItem_var {
    GCItem_var(GCItem *item = 0) : _item(item) {
    }

    GCItem_var& operator=(GCItem *item) {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var() {
      delete _item;
    }

    GCItem * operator->() const {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem {
    GCItem_Object(int own) : _own(own) {
    }

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem {
    GCItem_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem {
    GCArray_T(Type *ptr) : _ptr(ptr) {
    }

    virtual ~GCArray_T() {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (msg[0]) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, swig_msg.c_str());
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
    }

    virtual ~DirectorException() throw() {
    }

    /* Deprecated, use what() instead */
    const char *getMessage() const {
      return what();
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorException(error, msg);
    }

    static void raise(const char *msg) {
      raise(PyExc_RuntimeError, msg);
    }
  };

  /* type mismatch in the return value from a python method call */
  class DirectorTypeMismatchException : public DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char *msg="")
      : DirectorException(error, "SWIG director type mismatch", msg) {
    }

    DirectorTypeMismatchException(const char *msg="")
      : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) {
    }

    static void raise(PyObject *error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* any python exception that occurs during a director method call */
  class DirectorMethodException : public DirectorException {
  public:
    DirectorMethodException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorMethodException(msg);
    }
  };

  /* attempt to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg = "")
      : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };


#ifdef __THREAD__
#ifndef Py_LIMITED_API
   class Mutex
   {
   public:
       Mutex() {
           mutex_ = PyThread_allocate_lock();
       }

       ~Mutex() {
           PyThread_release_lock(mutex_);
       }

   private:
       void Lock() {
           PyThread_acquire_lock(mutex_, WAIT_LOCK);
       }

       void Unlock() {
           PyThread_free_lock(mutex_);
       }

       PyThread_type_lock mutex_;

       friend class Guard;
   };
#elif defined(_WIN32)
    class Mutex : private CRITICAL_SECTION {
    public:
        Mutex() {
            InitializeCriticalSection(this);
        }

        ~Mutex() {
            DeleteCriticalSection(this);
        }

    private:
        void Lock() {
            EnterCriticalSection(this);
        }

        void Unlock() {
            LeaveCriticalSection(this);
        }

        friend class Guard;
    };
#else
    class Mutex {
    public:
        Mutex() {
            pthread_mutex_init(&mutex_, NULL);
        }

        ~Mutex() {
            pthread_mutex_destroy(&mutex_);
        }

    private:
        void Lock() {
            pthread_mutex_lock(&mutex_);
        }

        void Unlock() {
            pthread_mutex_unlock(&mutex_);
        }

        friend class Guard;

        pthread_mutex_t mutex_;
    };
#endif
  class Guard {
    Mutex &mutex_;

  public:
    Guard(Mutex & mutex) : mutex_(mutex) {
      mutex_.Lock();
    }

    ~Guard() {
      mutex_.Unlock();
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped python object */
    PyObject *swig_self;
    /* flag indicating whether the object is owned by python or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped python object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_DECREF(swig_self);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }

  public:
    /* wrap a python object. */
    Director(PyObject *self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }

    /* return a pointer to the wrapped python object */
    PyObject *swig_get_self() const {
      return swig_self;
    }

    /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        SWIG_Py_INCREF(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static Mutex swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr) const {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    template <typename Type>
    static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) {
      SwigPyObject *sobj = (SwigPyObject *)pyobj;
      sobj->own = 0;
      Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
      if (d)
        d->swig_disown();
      return PyWeakref_NewProxy(pyobj, NULL);
    }
  };

#ifdef __THREAD__
  Mutex Director::swig_mutex_own;
#endif
}

#endif

/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_Xapian__AssertionError swig_types[0]
#define SWIGTYPE_p_Xapian__BB2Weight swig_types[1]
#define SWIGTYPE_p_Xapian__BM25PlusWeight swig_types[2]
#define SWIGTYPE_p_Xapian__BM25Weight swig_types[3]
#define SWIGTYPE_p_Xapian__BoolWeight swig_types[4]
#define SWIGTYPE_p_Xapian__Compactor swig_types[5]
#define SWIGTYPE_p_Xapian__CoordWeight swig_types[6]
#define SWIGTYPE_p_Xapian__DLHWeight swig_types[7]
#define SWIGTYPE_p_Xapian__DPHWeight swig_types[8]
#define SWIGTYPE_p_Xapian__Database swig_types[9]
#define SWIGTYPE_p_Xapian__DatabaseClosedError swig_types[10]
#define SWIGTYPE_p_Xapian__DatabaseCorruptError swig_types[11]
#define SWIGTYPE_p_Xapian__DatabaseCreateError swig_types[12]
#define SWIGTYPE_p_Xapian__DatabaseError swig_types[13]
#define SWIGTYPE_p_Xapian__DatabaseLockError swig_types[14]
#define SWIGTYPE_p_Xapian__DatabaseModifiedError swig_types[15]
#define SWIGTYPE_p_Xapian__DatabaseNotFoundError swig_types[16]
#define SWIGTYPE_p_Xapian__DatabaseOpeningError swig_types[17]
#define SWIGTYPE_p_Xapian__DatabaseVersionError swig_types[18]
#define SWIGTYPE_p_Xapian__DateRangeProcessor swig_types[19]
#define SWIGTYPE_p_Xapian__DecreasingValueWeightPostingSource swig_types[20]
#define SWIGTYPE_p_Xapian__DiceWeight swig_types[21]
#define SWIGTYPE_p_Xapian__DocNotFoundError swig_types[22]
#define SWIGTYPE_p_Xapian__Document swig_types[23]
#define SWIGTYPE_p_Xapian__ESet swig_types[24]
#define SWIGTYPE_p_Xapian__ESetIterator swig_types[25]
#define SWIGTYPE_p_Xapian__Enquire swig_types[26]
#define SWIGTYPE_p_Xapian__Error swig_types[27]
#define SWIGTYPE_p_Xapian__ExpandDecider swig_types[28]
#define SWIGTYPE_p_Xapian__ExpandDeciderAnd swig_types[29]
#define SWIGTYPE_p_Xapian__ExpandDeciderFilterPrefix swig_types[30]
#define SWIGTYPE_p_Xapian__ExpandDeciderFilterTerms swig_types[31]
#define SWIGTYPE_p_Xapian__FeatureUnavailableError swig_types[32]
#define SWIGTYPE_p_Xapian__FieldProcessor swig_types[33]
#define SWIGTYPE_p_Xapian__FixedWeightPostingSource swig_types[34]
#define SWIGTYPE_p_Xapian__GreatCircleMetric swig_types[35]
#define SWIGTYPE_p_Xapian__IfB2Weight swig_types[36]
#define SWIGTYPE_p_Xapian__InL2Weight swig_types[37]
#define SWIGTYPE_p_Xapian__IneB2Weight swig_types[38]
#define SWIGTYPE_p_Xapian__InternalError swig_types[39]
#define SWIGTYPE_p_Xapian__InvalidArgumentError swig_types[40]
#define SWIGTYPE_p_Xapian__InvalidOperationError swig_types[41]
#define SWIGTYPE_p_Xapian__KeyMaker swig_types[42]
#define SWIGTYPE_p_Xapian__LM2StageWeight swig_types[43]
#define SWIGTYPE_p_Xapian__LMAbsDiscountWeight swig_types[44]
#define SWIGTYPE_p_Xapian__LMDirichletWeight swig_types[45]
#define SWIGTYPE_p_Xapian__LMJMWeight swig_types[46]
#define SWIGTYPE_p_Xapian__LatLongCoord swig_types[47]
#define SWIGTYPE_p_Xapian__LatLongCoords swig_types[48]
#define SWIGTYPE_p_Xapian__LatLongCoordsIterator swig_types[49]
#define SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker swig_types[50]
#define SWIGTYPE_p_Xapian__LatLongDistancePostingSource swig_types[51]
#define SWIGTYPE_p_Xapian__LatLongMetric swig_types[52]
#define SWIGTYPE_p_Xapian__LogicError swig_types[53]
#define SWIGTYPE_p_Xapian__MSet swig_types[54]
#define SWIGTYPE_p_Xapian__MSetIterator swig_types[55]
#define SWIGTYPE_p_Xapian__MatchDecider swig_types[56]
#define SWIGTYPE_p_Xapian__MatchSpy swig_types[57]
#define SWIGTYPE_p_Xapian__MultiValueKeyMaker swig_types[58]
#define SWIGTYPE_p_Xapian__NetworkError swig_types[59]
#define SWIGTYPE_p_Xapian__NetworkTimeoutError swig_types[60]
#define SWIGTYPE_p_Xapian__NumberRangeProcessor swig_types[61]
#define SWIGTYPE_p_Xapian__PL2PlusWeight swig_types[62]
#define SWIGTYPE_p_Xapian__PL2Weight swig_types[63]
#define SWIGTYPE_p_Xapian__PositionIterator swig_types[64]
#define SWIGTYPE_p_Xapian__PostingIterator swig_types[65]
#define SWIGTYPE_p_Xapian__PostingSource swig_types[66]
#define SWIGTYPE_p_Xapian__Query swig_types[67]
#define SWIGTYPE_p_Xapian__QueryParser swig_types[68]
#define SWIGTYPE_p_Xapian__QueryParserError swig_types[69]
#define SWIGTYPE_p_Xapian__RSet swig_types[70]
#define SWIGTYPE_p_Xapian__RangeError swig_types[71]
#define SWIGTYPE_p_Xapian__RangeProcessor swig_types[72]
#define SWIGTYPE_p_Xapian__Registry swig_types[73]
#define SWIGTYPE_p_Xapian__RuntimeError swig_types[74]
#define SWIGTYPE_p_Xapian__SerialisationError swig_types[75]
#define SWIGTYPE_p_Xapian__SimpleStopper swig_types[76]
#define SWIGTYPE_p_Xapian__Stem swig_types[77]
#define SWIGTYPE_p_Xapian__StemImplementation swig_types[78]
#define SWIGTYPE_p_Xapian__Stopper swig_types[79]
#define SWIGTYPE_p_Xapian__TermGenerator swig_types[80]
#define SWIGTYPE_p_Xapian__TermIterator swig_types[81]
#define SWIGTYPE_p_Xapian__TfIdfWeight swig_types[82]
#define SWIGTYPE_p_Xapian__TradWeight swig_types[83]
#define SWIGTYPE_p_Xapian__UnimplementedError swig_types[84]
#define SWIGTYPE_p_Xapian__UnitRangeProcessor swig_types[85]
#define SWIGTYPE_p_Xapian__ValueCountMatchSpy swig_types[86]
#define SWIGTYPE_p_Xapian__ValueIterator swig_types[87]
#define SWIGTYPE_p_Xapian__ValueMapPostingSource swig_types[88]
#define SWIGTYPE_p_Xapian__ValuePostingSource swig_types[89]
#define SWIGTYPE_p_Xapian__ValueSetMatchDecider swig_types[90]
#define SWIGTYPE_p_Xapian__ValueWeightPostingSource swig_types[91]
#define SWIGTYPE_p_Xapian__Weight swig_types[92]
#define SWIGTYPE_p_Xapian__WildcardError swig_types[93]
#define SWIGTYPE_p_Xapian__WritableDatabase swig_types[94]
#define SWIGTYPE_p_char swig_types[95]
#define SWIGTYPE_p_compaction_level swig_types[96]
#define SWIGTYPE_p_const_reference swig_types[97]
#define SWIGTYPE_p_docid_order swig_types[98]
#define SWIGTYPE_p_double swig_types[99]
#define SWIGTYPE_p_feature_flag swig_types[100]
#define SWIGTYPE_p_flags swig_types[101]
#define SWIGTYPE_p_int swig_types[102]
#define SWIGTYPE_p_reference swig_types[103]
#define SWIGTYPE_p_std__invalid_argument swig_types[104]
#define SWIGTYPE_p_std__string swig_types[105]
#define SWIGTYPE_p_stem_strategy swig_types[106]
#define SWIGTYPE_p_stop_strategy swig_types[107]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[108]
#define SWIGTYPE_p_unsigned_int swig_types[109]
#define SWIGTYPE_p_unsigned_long swig_types[110]
static swig_type_info *swig_types[112];
static swig_module_info swig_module = {swig_types, 111, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _xapian.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__xapian

#else
#  define SWIG_init    init_xapian

#endif
#define SWIG_name    "_xapian"

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(item._obj);
      SWIG_Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      SWIG_Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


/* python.i: SWIG interface file for the Python bindings
 *
 * Copyright (C) 2011-2023 Olly Betts
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */


/** @file
 * @brief Set xapian.__version__ to the bindings version
 */
/* Copyright (C) 2013 Olly Betts
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */


/** @file
 * @brief Header for SWIG interface file for Xapian.
 */
/* Copyright (C) 2005,2006,2007,2008,2009,2011,2012,2013,2014,2015,2016,2017 Olly Betts
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */

// Disable any deprecation warnings for Xapian methods/functions/classes.
#define XAPIAN_DEPRECATED(D) D

#include <xapian.h>

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

// If the remote backend has been disabled in xapian-core (manually or
// automatically) we include a stub definition here so the bindings can still
// be built.
namespace Xapian {

#ifndef XAPIAN_HAS_REMOTE_BACKEND
    namespace Remote {
        static Database open(const string &, unsigned int, unsigned = 0, unsigned = 0) {
            throw FeatureUnavailableError("Remote backend not supported");
        }

        static WritableDatabase open_writable(const string &, unsigned int, unsigned = 0, unsigned = 0, int = 0) {
            throw FeatureUnavailableError("Remote backend not supported");
        }

        static Database open(const string &, const string &, unsigned = 0) {
            throw FeatureUnavailableError("Remote backend not supported");
        }

        static WritableDatabase open_writable(const string &, const string &, unsigned = 0, int = 0) {
            throw FeatureUnavailableError("Remote backend not supported");
        }
    }
#endif

}


#include <typeinfo>
#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>


#include <stddef.h>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICEOBJECT PyObject
#else
# define SWIGPY_SLICEOBJECT PySliceObject
#endif


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }
      
  public:
    virtual ~SwigPyIterator() {}

    // Access iterator method, required by Python
    virtual PyObject *value() const = 0;

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      throw stop_iteration();
    }

    // Random access iterator methods, but not required in Python
    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    // C++ common/needed methods
    virtual SwigPyIterator *copy() const = 0;

    PyObject *next()     
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      PyObject *obj = value();
      incr();       
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

    /* Make an alias for Python 3.x */
    PyObject *__next__()
    {
      return next();
    }

    PyObject *previous()
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      decr();
      PyObject *obj = value();
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
      return obj;
    }

    SwigPyIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const SwigPyIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const SwigPyIterator& x) const
    {
      return ! operator==(x);
    }
      
    SwigPyIterator& operator += (ptrdiff_t n)
    {
      return *advance(n);
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }
      
    SwigPyIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    SwigPyIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const SwigPyIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
	init = 1;
      }	
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    SWIG_Py_INCREF(pyself);
    return pyself;
  }
#endif
}


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


  #define SWIG_From_long   PyInt_FromLong 


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


#include <vector>


#include <utility>


#include <map>


#include <algorithm>


#include <string_view>

#if PY_VERSION_HEX < 0x03000000
# error std_string_view.i not supported for Python 2
#endif


/* python/extracomments.i: Custom written documentation comments.
 *
 * Copyright (C) 2007 Lemur Consulting Ltd
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */


/* python/util.i: custom Python typemaps for xapian-bindings
 *
 * Copyright (C) 2002,2003 James Aylett
 * Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2013,2016,2017,2019 Olly Betts
 * Copyright (C) 2007 Lemur Consulting Ltd
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */


namespace Xapian {
    Query *get_py_query(PyObject *obj) {
        PyObject * mythis = PyObject_GetAttrString(obj, "this");
        if (!mythis)
            return 0;

        Query * retval = 0;
        int res = SWIG_ConvertPtr(mythis, (void **)&retval,
                                  SWIGTYPE_p_Xapian__Query, 0);
        if (!SWIG_IsOK(res)) {
            retval = 0;
        }
        Py_DECREF(mythis);
        return retval;
    }
}


class XapianSWIGQueryItor {
    mutable PyObject * seq;

    int i;

    /// str_obj must be a bytes object
    Xapian::Query str_obj_to_query(PyObject * str_obj) const {
        char * p;
        Py_ssize_t len;
        (void)PyBytes_AsStringAndSize(str_obj, &p, &len);
        return Xapian::Query(string(p, len));
    }

  public:
    typedef std::random_access_iterator_tag iterator_category;
    typedef Xapian::Query value_type;
    typedef Xapian::termcount_diff difference_type;
    typedef Xapian::Query * pointer;
    typedef Xapian::Query & reference;

    XapianSWIGQueryItor() : seq(NULL), i(0) { }

    void begin(PyObject * seq_) {
        seq = seq_;
    }

    void end(PyObject * seq_) {
        i = PySequence_Fast_GET_SIZE(seq_);
    }

    void free_seq() {
        Py_CLEAR(seq);
    }

    XapianSWIGQueryItor & operator++() {
        ++i;
        return *this;
    }

    Xapian::Query operator*() const {
        PyObject * obj = PySequence_Fast_GET_ITEM(seq, i);

        // Unicode object.
        if (PyUnicode_Check(obj)) {
            PyObject* s = PyUnicode_AsUTF8String(obj);
            if (!s) goto fail;
            Xapian::Query result = str_obj_to_query(s);
            Py_DECREF(s);
            return result;
        }

        // String.
        if (PyBytes_Check(obj))
            return str_obj_to_query(obj);

        // xapian.Query object (or unexpected object type).
        {
            Xapian::Query * result_ptr = Xapian::get_py_query(obj);
            if (result_ptr) return *result_ptr;
        }

    fail:
        throw Xapian::InvalidArgumentError("Expected Query object or string");
    }

    bool operator==(const XapianSWIGQueryItor & o) {
        return i == o.i;
    }

    bool operator!=(const XapianSWIGQueryItor & o) {
        return !(*this == o);
    }

    difference_type operator-(const XapianSWIGQueryItor &o) const {
        return i - o.i;
    }
};



SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}

SWIGINTERN std::string Xapian_Error___str__(Xapian::Error const *self){
        std::string desc(self->get_msg());
        if (!self->get_context().empty()) {
            desc += " (context: ";
            desc += self->get_context();
            desc += ')';
        }
        if (self->get_error_string()) {
            desc += " (";
            desc += self->get_error_string();
            desc += ')';
        }
        return desc;
    }

/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}





SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}


namespace Xapian {
SWIGEXPORT void SetPythonException() {
    try {
        throw;
    } catch (Swig::DirectorException &) {
        /* This happens if a director raised an exception.  The standard SWIG
         * director exception handling code sets the Python error state if
         * necessary, so we don't need to do anything. */
    } catch (const Xapian::DatabaseClosedError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseClosedError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseClosedError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseClosedError",
                          SWIGTYPE_p_Xapian__DatabaseClosedError);
    } catch (const Xapian::DatabaseNotFoundError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseNotFoundError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseNotFoundError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseNotFoundError",
                          SWIGTYPE_p_Xapian__DatabaseNotFoundError);
    } catch (const Xapian::WildcardError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::WildcardError(e)),
                                             SWIGTYPE_p_Xapian__WildcardError,
                                             SWIG_POINTER_OWN),
                          "Xapian::WildcardError",
                          SWIGTYPE_p_Xapian__WildcardError);
    } catch (const Xapian::RangeError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::RangeError(e)),
                                             SWIGTYPE_p_Xapian__RangeError,
                                             SWIG_POINTER_OWN),
                          "Xapian::RangeError",
                          SWIGTYPE_p_Xapian__RangeError);
    } catch (const Xapian::SerialisationError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::SerialisationError(e)),
                                             SWIGTYPE_p_Xapian__SerialisationError,
                                             SWIG_POINTER_OWN),
                          "Xapian::SerialisationError",
                          SWIGTYPE_p_Xapian__SerialisationError);
    } catch (const Xapian::QueryParserError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::QueryParserError(e)),
                                             SWIGTYPE_p_Xapian__QueryParserError,
                                             SWIG_POINTER_OWN),
                          "Xapian::QueryParserError",
                          SWIGTYPE_p_Xapian__QueryParserError);
    } catch (const Xapian::NetworkTimeoutError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::NetworkTimeoutError(e)),
                                             SWIGTYPE_p_Xapian__NetworkTimeoutError,
                                             SWIG_POINTER_OWN),
                          "Xapian::NetworkTimeoutError",
                          SWIGTYPE_p_Xapian__NetworkTimeoutError);
    } catch (const Xapian::NetworkError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::NetworkError(e)),
                                             SWIGTYPE_p_Xapian__NetworkError,
                                             SWIG_POINTER_OWN),
                          "Xapian::NetworkError",
                          SWIGTYPE_p_Xapian__NetworkError);
    } catch (const Xapian::InternalError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::InternalError(e)),
                                             SWIGTYPE_p_Xapian__InternalError,
                                             SWIG_POINTER_OWN),
                          "Xapian::InternalError",
                          SWIGTYPE_p_Xapian__InternalError);
    } catch (const Xapian::FeatureUnavailableError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::FeatureUnavailableError(e)),
                                             SWIGTYPE_p_Xapian__FeatureUnavailableError,
                                             SWIG_POINTER_OWN),
                          "Xapian::FeatureUnavailableError",
                          SWIGTYPE_p_Xapian__FeatureUnavailableError);
    } catch (const Xapian::DocNotFoundError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DocNotFoundError(e)),
                                             SWIGTYPE_p_Xapian__DocNotFoundError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DocNotFoundError",
                          SWIGTYPE_p_Xapian__DocNotFoundError);
    } catch (const Xapian::DatabaseVersionError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseVersionError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseVersionError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseVersionError",
                          SWIGTYPE_p_Xapian__DatabaseVersionError);
    } catch (const Xapian::DatabaseOpeningError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseOpeningError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseOpeningError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseOpeningError",
                          SWIGTYPE_p_Xapian__DatabaseOpeningError);
    } catch (const Xapian::DatabaseModifiedError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseModifiedError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseModifiedError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseModifiedError",
                          SWIGTYPE_p_Xapian__DatabaseModifiedError);
    } catch (const Xapian::DatabaseLockError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseLockError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseLockError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseLockError",
                          SWIGTYPE_p_Xapian__DatabaseLockError);
    } catch (const Xapian::DatabaseCreateError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseCreateError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseCreateError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseCreateError",
                          SWIGTYPE_p_Xapian__DatabaseCreateError);
    } catch (const Xapian::DatabaseCorruptError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseCorruptError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseCorruptError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseCorruptError",
                          SWIGTYPE_p_Xapian__DatabaseCorruptError);
    } catch (const Xapian::DatabaseError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::DatabaseError(e)),
                                             SWIGTYPE_p_Xapian__DatabaseError,
                                             SWIG_POINTER_OWN),
                          "Xapian::DatabaseError",
                          SWIGTYPE_p_Xapian__DatabaseError);
    } catch (const Xapian::UnimplementedError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::UnimplementedError(e)),
                                             SWIGTYPE_p_Xapian__UnimplementedError,
                                             SWIG_POINTER_OWN),
                          "Xapian::UnimplementedError",
                          SWIGTYPE_p_Xapian__UnimplementedError);
    } catch (const Xapian::InvalidOperationError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::InvalidOperationError(e)),
                                             SWIGTYPE_p_Xapian__InvalidOperationError,
                                             SWIG_POINTER_OWN),
                          "Xapian::InvalidOperationError",
                          SWIGTYPE_p_Xapian__InvalidOperationError);
    } catch (const Xapian::InvalidArgumentError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::InvalidArgumentError(e)),
                                             SWIGTYPE_p_Xapian__InvalidArgumentError,
                                             SWIG_POINTER_OWN),
                          "Xapian::InvalidArgumentError",
                          SWIGTYPE_p_Xapian__InvalidArgumentError);
    } catch (const Xapian::AssertionError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::AssertionError(e)),
                                             SWIGTYPE_p_Xapian__AssertionError,
                                             SWIG_POINTER_OWN),
                          "Xapian::AssertionError",
                          SWIGTYPE_p_Xapian__AssertionError);
    } catch (const Xapian::RuntimeError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::RuntimeError(e)),
                                             SWIGTYPE_p_Xapian__RuntimeError,
                                             SWIG_POINTER_OWN),
                          "Xapian::RuntimeError",
                          SWIGTYPE_p_Xapian__RuntimeError);
    } catch (const Xapian::LogicError &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::LogicError(e)),
                                             SWIGTYPE_p_Xapian__LogicError,
                                             SWIG_POINTER_OWN),
                          "Xapian::LogicError",
                          SWIGTYPE_p_Xapian__LogicError);
    } catch (const Xapian::Error &e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new Xapian::Error(e)),
                                             SWIGTYPE_p_Xapian__Error,
                                             SWIG_POINTER_OWN),
                          "Xapian::Error",
                          SWIGTYPE_p_Xapian__Error);
    } catch (const std::exception& e) {
        SWIG_Error(SWIG_RuntimeError, e.what());
    } catch (...) {
        SWIG_Error(SWIG_UnknownError, "unknown error in Xapian");
    }
}
}


/* xapian-headers.i: Getting SWIG to parse Xapian's C++ headers.
 *
 * Copyright 2004-2024 Olly Betts
 * Copyright 2014 Assem Chelli
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}

SWIGINTERN bool Xapian_PositionIterator___eq__(Xapian::PositionIterator *self,Xapian::PositionIterator const &other){
            return (*self)==other;
        }
SWIGINTERN bool Xapian_PositionIterator___ne__(Xapian::PositionIterator *self,Xapian::PositionIterator const &other){
            return (*self)!=other;
        }
SWIGINTERN bool Xapian_PositionIterator_equals(Xapian::PositionIterator const *self,Xapian::PositionIterator const &o){ return *self == o; }
SWIGINTERN Xapian::termpos Xapian_PositionIterator_get_termpos(Xapian::PositionIterator const *self){ return **self; }
SWIGINTERN void Xapian_PositionIterator_next(Xapian::PositionIterator *self){ ++(*self); }
SWIGINTERN bool Xapian_PostingIterator___eq__(Xapian::PostingIterator *self,Xapian::PostingIterator const &other){
            return (*self)==other;
        }
SWIGINTERN bool Xapian_PostingIterator___ne__(Xapian::PostingIterator *self,Xapian::PostingIterator const &other){
            return (*self)!=other;
        }
SWIGINTERN bool Xapian_PostingIterator_equals(Xapian::PostingIterator const *self,Xapian::PostingIterator const &o){ return *self == o; }
SWIGINTERN Xapian::docid Xapian_PostingIterator_get_docid(Xapian::PostingIterator const *self){ return **self; }
SWIGINTERN void Xapian_PostingIterator_next(Xapian::PostingIterator *self){ ++(*self); }
SWIGINTERN bool Xapian_TermIterator___eq__(Xapian::TermIterator *self,Xapian::TermIterator const &other){
            return (*self)==other;
        }
SWIGINTERN bool Xapian_TermIterator___ne__(Xapian::TermIterator *self,Xapian::TermIterator const &other){
            return (*self)!=other;
        }
SWIGINTERN bool Xapian_TermIterator_equals(Xapian::TermIterator const *self,Xapian::TermIterator const &o){ return *self == o; }
SWIGINTERN std::string Xapian_TermIterator_get_term(Xapian::TermIterator const *self){ return **self; }
SWIGINTERN void Xapian_TermIterator_next(Xapian::TermIterator *self){ ++(*self); }
SWIGINTERN bool Xapian_ValueIterator___eq__(Xapian::ValueIterator *self,Xapian::ValueIterator const &other){
            return (*self)==other;
        }
SWIGINTERN bool Xapian_ValueIterator___ne__(Xapian::ValueIterator *self,Xapian::ValueIterator const &other){
            return (*self)!=other;
        }
SWIGINTERN bool Xapian_ValueIterator_equals(Xapian::ValueIterator const *self,Xapian::ValueIterator const &o){ return *self == o; }
SWIGINTERN std::string Xapian_ValueIterator_get_value(Xapian::ValueIterator const *self){ return **self; }
SWIGINTERN void Xapian_ValueIterator_next(Xapian::ValueIterator *self){ ++(*self); }

SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN Xapian::Query *new_Xapian_Query__SWIG_19(Xapian::Query::op op_,std::string_view a,std::string_view b){
        return new Xapian::Query(op_, a, b);
    }

SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


/* Utility function which works like SWIG_AsPtr_std_string, but
 * converts unicode strings to UTF-8 simple strings first. */
static int
XapianSWIG_anystring_as_ptr(PyObject * obj, std::string **val)
{
    if (PyUnicode_Check(obj)) {
        PyObject* strobj = PyUnicode_AsUTF8String(obj);
        if (strobj == NULL) return INT_MIN;
        char *p;
        Py_ssize_t len;
        PyBytes_AsStringAndSize(strobj, &p, &len);
        if (val) *val = new std::string(p, len);
        Py_DECREF(strobj);
        return SWIG_NEWOBJ;
    } else if (PyBytes_Check(obj)) {
        char *p;
        Py_ssize_t len;
        PyBytes_AsStringAndSize(obj, &p, &len);
        if (val) *val = new std::string(p, len);
        return SWIG_NEWOBJ;
    } else {
        return SWIG_AsPtr_std_string(obj, val);
    }
}


SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}


  #define SWIG_From_double   PyFloat_FromDouble 

SWIGINTERN Xapian::docid Xapian_MSet_get_docid(Xapian::MSet const *self,Xapian::doccount i){
        return *(*self)[i];
    }
SWIGINTERN Xapian::Document Xapian_MSet_get_document(Xapian::MSet const *self,Xapian::doccount i){
        return (*self)[i].get_document();
    }
SWIGINTERN Xapian::MSetIterator Xapian_MSet_get_hit(Xapian::MSet const *self,Xapian::doccount i){
        return (*self)[i];
    }
SWIGINTERN int Xapian_MSet_get_document_percentage(Xapian::MSet const *self,Xapian::doccount i){
        return self->convert_to_percent((*self)[i]);
    }
SWIGINTERN bool Xapian_MSetIterator___eq__(Xapian::MSetIterator *self,Xapian::MSetIterator const &other){
            return (*self)==other;
        }
SWIGINTERN bool Xapian_MSetIterator___ne__(Xapian::MSetIterator *self,Xapian::MSetIterator const &other){
            return (*self)!=other;
        }
SWIGINTERN bool Xapian_MSetIterator_equals(Xapian::MSetIterator const *self,Xapian::MSetIterator const &o){ return *self == o; }
SWIGINTERN Xapian::docid Xapian_MSetIterator_get_docid(Xapian::MSetIterator const *self){ return **self; }
SWIGINTERN void Xapian_MSetIterator_next(Xapian::MSetIterator *self){ ++(*self); }
SWIGINTERN void Xapian_MSetIterator_prev(Xapian::MSetIterator *self){ --(*self); }
SWIGINTERN bool Xapian_ESetIterator___eq__(Xapian::ESetIterator *self,Xapian::ESetIterator const &other){
            return (*self)==other;
        }
SWIGINTERN bool Xapian_ESetIterator___ne__(Xapian::ESetIterator *self,Xapian::ESetIterator const &other){
            return (*self)!=other;
        }
SWIGINTERN bool Xapian_ESetIterator_equals(Xapian::ESetIterator const *self,Xapian::ESetIterator const &o){ return *self == o; }
SWIGINTERN std::string Xapian_ESetIterator_get_term(Xapian::ESetIterator const *self){ return **self; }
SWIGINTERN void Xapian_ESetIterator_next(Xapian::ESetIterator *self){ ++(*self); }
SWIGINTERN void Xapian_ESetIterator_prev(Xapian::ESetIterator *self){ --(*self); }
SWIGINTERN Xapian::SimpleStopper *new_Xapian_SimpleStopper__SWIG_1(std::string const &file){
        ifstream in_file(file.c_str());
        if (!in_file.is_open())
            throw Xapian::InvalidArgumentError("Stopword file not found: " + file);
        istream_iterator<std::string> in_iter(in_file);
        istream_iterator<std::string> eof;
        return new Xapian::SimpleStopper(in_iter, eof);
    }
SWIGINTERN bool Xapian_LatLongCoordsIterator_equals(Xapian::LatLongCoordsIterator const *self,Xapian::LatLongCoordsIterator const &o){ return *self == o; }
SWIGINTERN Xapian::LatLongCoord Xapian_LatLongCoordsIterator_get_coord(Xapian::LatLongCoordsIterator const *self){ return **self; }
SWIGINTERN void Xapian_LatLongCoordsIterator_next(Xapian::LatLongCoordsIterator *self){ ++(*self); }

/* python/extra.i: Xapian scripting python interface additional python code.
 *
 * Copyright (C) 2003,2004,2005 James Aylett
 * Copyright (C) 2005,2006,2007,2008,2009,2010,2011,2013 Olly Betts
 * Copyright (C) 2007 Lemur Consulting Ltd
 * Copyright (C) 2010 Richard Boulton
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */



/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "xapian_wrap.h"

SwigDirector_StemImplementation::SwigDirector_StemImplementation(PyObject *self): Xapian::StemImplementation(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::StemImplementation *)this, this); 
}




SwigDirector_StemImplementation::~SwigDirector_StemImplementation() {
}

std::string SwigDirector_StemImplementation::operator ()(std::string const &word) {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(word.data(), word.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StemImplementation.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


bool SwigDirector_StemImplementation::use_proper_noun_heuristic() const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StemImplementation.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "use_proper_noun_heuristic";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("use_proper_noun_heuristic");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


std::string SwigDirector_StemImplementation::get_description() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StemImplementation.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "__str__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__str__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_MatchDecider::SwigDirector_MatchDecider(PyObject *self): Xapian::MatchDecider(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::MatchDecider *)this, this); 
}




SwigDirector_MatchDecider::~SwigDirector_MatchDecider() {
}

bool SwigDirector_MatchDecider::operator ()(Xapian::Document const &doc) const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&doc), SWIGTYPE_p_Xapian__Document,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MatchDecider.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


SwigDirector_ExpandDecider::SwigDirector_ExpandDecider(PyObject *self): Xapian::ExpandDecider(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::ExpandDecider *)this, this); 
}




bool SwigDirector_ExpandDecider::operator ()(std::string const &term) const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(term.data(), term.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ExpandDecider.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


SwigDirector_ExpandDecider::~SwigDirector_ExpandDecider() {
}

SwigDirector_KeyMaker::SwigDirector_KeyMaker(PyObject *self): Xapian::KeyMaker(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::KeyMaker *)this, this); 
}




std::string SwigDirector_KeyMaker::operator ()(Xapian::Document const &doc) const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&doc), SWIGTYPE_p_Xapian__Document,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call KeyMaker.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_KeyMaker::~SwigDirector_KeyMaker() {
}

std::string SwigDirector_KeyMaker::name() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call KeyMaker.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "name";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


std::string SwigDirector_KeyMaker::serialise() const {
  return Xapian::KeyMaker::serialise();
}


Xapian::KeyMaker *SwigDirector_KeyMaker::unserialise(std::string const &serialised,Xapian::Registry const &context) const {
  return Xapian::KeyMaker::unserialise(serialised,context);
}


SwigDirector_Stopper::SwigDirector_Stopper(PyObject *self): Xapian::Stopper(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::Stopper *)this, this); 
}




bool SwigDirector_Stopper::operator ()(std::string const &term) const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(term.data(), term.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Stopper.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


SwigDirector_Stopper::~SwigDirector_Stopper() {
}

std::string SwigDirector_Stopper::get_description() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Stopper.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "__str__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__str__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_RangeProcessor::SwigDirector_RangeProcessor(PyObject *self): Xapian::RangeProcessor(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::RangeProcessor *)this, this); 
}




SwigDirector_RangeProcessor::SwigDirector_RangeProcessor(PyObject *self,Xapian::valueno slot_,std::string_view str_,unsigned int flags_): Xapian::RangeProcessor(slot_, str_, flags_), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::RangeProcessor *)this, this); 
}




SwigDirector_RangeProcessor::~SwigDirector_RangeProcessor() {
}

Xapian::Query SwigDirector_RangeProcessor::operator ()(std::string const &begin,std::string const &end) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  Xapian::Query c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(begin.data(), begin.size());
    
    swig::SwigVar_PyObject obj1;
    
    obj1 = PyBytes_FromStringAndSize(end.data(), end.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call RangeProcessor.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Xapian__Query,  0  | 0);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::Query""'");
    }
    c_result = *(reinterpret_cast< Xapian::Query * >(swig_argp));
    if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Xapian::Query * >(swig_argp);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::Query) c_result;
}


SwigDirector_FieldProcessor::SwigDirector_FieldProcessor(PyObject *self): Xapian::FieldProcessor(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::FieldProcessor *)this, this); 
}




SwigDirector_FieldProcessor::~SwigDirector_FieldProcessor() {
}

Xapian::Query SwigDirector_FieldProcessor::operator ()(std::string const &str) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  Xapian::Query c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(str.data(), str.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FieldProcessor.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Xapian__Query,  0  | 0);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::Query""'");
    }
    c_result = *(reinterpret_cast< Xapian::Query * >(swig_argp));
    if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Xapian::Query * >(swig_argp);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::Query) c_result;
}


SwigDirector_Compactor::SwigDirector_Compactor(PyObject *self): Xapian::Compactor(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::Compactor *)this, this); 
}




SwigDirector_Compactor::~SwigDirector_Compactor() {
}

void SwigDirector_Compactor::set_status(std::string const &table,std::string const &status) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(table.data(), table.size());
    
    swig::SwigVar_PyObject obj1;
    
    obj1 = PyBytes_FromStringAndSize(status.data(), status.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Compactor.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "set_status";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("set_status");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


std::string SwigDirector_Compactor::resolve_duplicate_metadata(std::string const &key,size_t num_tags,std::string const tags[]) {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(key.data(), key.size());
    
    swig::SwigVar_PyObject obj1;
    {
      PyObject * result = PyList_New(num_tags);
      if (result == 0) {
        return NULL;
      }
      
      for (size_t i = 0; i != num_tags; ++i) {
        PyObject * str = PyBytes_FromStringAndSize(tags[i].data(), tags[i].size());
        if (str == 0) {
          Py_DECREF(result);
          return NULL;
        }
        
        PyList_SET_ITEM(result, i, str);
      }
      obj1 = result;
    }
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Compactor.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "resolve_duplicate_metadata";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("resolve_duplicate_metadata");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_PostingSource::SwigDirector_PostingSource(PyObject *self): Xapian::PostingSource(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::PostingSource *)this, this); 
}




SwigDirector_PostingSource::~SwigDirector_PostingSource() {
}

Xapian::doccount SwigDirector_PostingSource::get_termfreq_min() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "get_termfreq_min";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_min");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


Xapian::doccount SwigDirector_PostingSource::get_termfreq_est() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "get_termfreq_est";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_est");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


Xapian::doccount SwigDirector_PostingSource::get_termfreq_max() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "get_termfreq_max";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_max");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


double SwigDirector_PostingSource::get_weight() const {
  double c_result = SwigValueInit< double >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 3;
    const char *const swig_method_name = "get_weight";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_weight");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    double swig_val;
    int swig_res = SWIG_AsVal_double(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
    }
    c_result = static_cast< double >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (double) c_result;
}


Xapian::docid SwigDirector_PostingSource::get_docid() const {
  Xapian::docid c_result = SwigValueInit< Xapian::docid >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 4;
    const char *const swig_method_name = "get_docid";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_docid");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::docid""'");
    }
    c_result = static_cast< Xapian::docid >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::docid) c_result;
}


void SwigDirector_PostingSource::next(double min_wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 5;
    const char *const swig_method_name = "__next__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__next__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_PostingSource::skip_to(Xapian::docid did,double min_wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(did));
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 6;
    const char *const swig_method_name = "skip_to";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("skip_to");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


bool SwigDirector_PostingSource::check(Xapian::docid did,double min_wt) {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(did));
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 7;
    const char *const swig_method_name = "check";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("check");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


bool SwigDirector_PostingSource::at_end() const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 8;
    const char *const swig_method_name = "at_end";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("at_end");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


Xapian::PostingSource *SwigDirector_PostingSource::clone() const {
  return Xapian::PostingSource::clone();
}


std::string SwigDirector_PostingSource::name() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 9;
    const char *const swig_method_name = "name";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


std::string SwigDirector_PostingSource::serialise() const {
  return Xapian::PostingSource::serialise();
}


Xapian::PostingSource *SwigDirector_PostingSource::unserialise(std::string const &serialised) const {
  return Xapian::PostingSource::unserialise(serialised);
}


Xapian::PostingSource *SwigDirector_PostingSource::unserialise_with_registry(std::string const &serialised,Xapian::Registry const &registry) const {
  return Xapian::PostingSource::unserialise_with_registry(serialised,registry);
}


void SwigDirector_PostingSource::reset(Xapian::Database const &db,Xapian::doccount shard_index) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&db), SWIGTYPE_p_Xapian__Database,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(shard_index));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 10;
    const char *const swig_method_name = "reset";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("reset");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_PostingSource::init(Xapian::Database const &db) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&db), SWIGTYPE_p_Xapian__Database,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 11;
    const char *const swig_method_name = "init";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("init");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


std::string SwigDirector_PostingSource::get_description() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 12;
    const char *const swig_method_name = "__str__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__str__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_ValuePostingSource::SwigDirector_ValuePostingSource(PyObject *self,Xapian::valueno slot_): Xapian::ValuePostingSource(slot_), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::ValuePostingSource *)this, this); 
}




SwigDirector_ValuePostingSource::~SwigDirector_ValuePostingSource() {
}

Xapian::doccount SwigDirector_ValuePostingSource::get_termfreq_min() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "get_termfreq_min";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_min");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


Xapian::doccount SwigDirector_ValuePostingSource::get_termfreq_est() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "get_termfreq_est";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_est");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


Xapian::doccount SwigDirector_ValuePostingSource::get_termfreq_max() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "get_termfreq_max";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_max");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


double SwigDirector_ValuePostingSource::get_weight() const {
  double c_result = SwigValueInit< double >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 3;
    const char *const swig_method_name = "get_weight";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_weight");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    double swig_val;
    int swig_res = SWIG_AsVal_double(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
    }
    c_result = static_cast< double >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (double) c_result;
}


Xapian::docid SwigDirector_ValuePostingSource::get_docid() const {
  Xapian::docid c_result = SwigValueInit< Xapian::docid >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 4;
    const char *const swig_method_name = "get_docid";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_docid");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::docid""'");
    }
    c_result = static_cast< Xapian::docid >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::docid) c_result;
}


void SwigDirector_ValuePostingSource::next(double min_wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 5;
    const char *const swig_method_name = "__next__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__next__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_ValuePostingSource::skip_to(Xapian::docid min_docid,double min_wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(min_docid));
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 6;
    const char *const swig_method_name = "skip_to";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("skip_to");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


bool SwigDirector_ValuePostingSource::check(Xapian::docid min_docid,double min_wt) {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(min_docid));
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 7;
    const char *const swig_method_name = "check";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("check");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


bool SwigDirector_ValuePostingSource::at_end() const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 8;
    const char *const swig_method_name = "at_end";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("at_end");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


Xapian::PostingSource *SwigDirector_ValuePostingSource::clone() const {
  return Xapian::PostingSource::clone();
}


std::string SwigDirector_ValuePostingSource::name() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 9;
    const char *const swig_method_name = "name";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


std::string SwigDirector_ValuePostingSource::serialise() const {
  return Xapian::PostingSource::serialise();
}


Xapian::PostingSource *SwigDirector_ValuePostingSource::unserialise(std::string const &serialised) const {
  return Xapian::PostingSource::unserialise(serialised);
}


Xapian::PostingSource *SwigDirector_ValuePostingSource::unserialise_with_registry(std::string const &serialised,Xapian::Registry const &registry) const {
  return Xapian::PostingSource::unserialise_with_registry(serialised,registry);
}


void SwigDirector_ValuePostingSource::reset(Xapian::Database const &db_,Xapian::doccount shard_index) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&db_), SWIGTYPE_p_Xapian__Database,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(shard_index));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 10;
    const char *const swig_method_name = "reset";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("reset");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_ValuePostingSource::init(Xapian::Database const &db) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&db), SWIGTYPE_p_Xapian__Database,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 11;
    const char *const swig_method_name = "init";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("init");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


std::string SwigDirector_ValuePostingSource::get_description() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValuePostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 12;
    const char *const swig_method_name = "__str__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__str__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_ValueWeightPostingSource::SwigDirector_ValueWeightPostingSource(PyObject *self,Xapian::valueno slot_): Xapian::ValueWeightPostingSource(slot_), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::ValueWeightPostingSource *)this, this); 
}




SwigDirector_ValueWeightPostingSource::~SwigDirector_ValueWeightPostingSource() {
}

Xapian::doccount SwigDirector_ValueWeightPostingSource::get_termfreq_min() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "get_termfreq_min";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_min");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


Xapian::doccount SwigDirector_ValueWeightPostingSource::get_termfreq_est() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "get_termfreq_est";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_est");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


Xapian::doccount SwigDirector_ValueWeightPostingSource::get_termfreq_max() const {
  Xapian::doccount c_result = SwigValueInit< Xapian::doccount >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "get_termfreq_max";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_termfreq_max");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::doccount""'");
    }
    c_result = static_cast< Xapian::doccount >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::doccount) c_result;
}


double SwigDirector_ValueWeightPostingSource::get_weight() const {
  double c_result = SwigValueInit< double >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 3;
    const char *const swig_method_name = "get_weight";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_weight");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    double swig_val;
    int swig_res = SWIG_AsVal_double(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
    }
    c_result = static_cast< double >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (double) c_result;
}


Xapian::docid SwigDirector_ValueWeightPostingSource::get_docid() const {
  Xapian::docid c_result = SwigValueInit< Xapian::docid >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 4;
    const char *const swig_method_name = "get_docid";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("get_docid");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    unsigned int swig_val;
    int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Xapian::docid""'");
    }
    c_result = static_cast< Xapian::docid >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (Xapian::docid) c_result;
}


void SwigDirector_ValueWeightPostingSource::next(double min_wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 5;
    const char *const swig_method_name = "__next__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__next__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_ValueWeightPostingSource::skip_to(Xapian::docid min_docid,double min_wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(min_docid));
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 6;
    const char *const swig_method_name = "skip_to";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("skip_to");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


bool SwigDirector_ValueWeightPostingSource::check(Xapian::docid min_docid,double min_wt) {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(min_docid));
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(min_wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 7;
    const char *const swig_method_name = "check";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("check");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


bool SwigDirector_ValueWeightPostingSource::at_end() const {
  bool c_result = SwigValueInit< bool >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 8;
    const char *const swig_method_name = "at_end";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("at_end");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    bool swig_val;
    int swig_res = SWIG_AsVal_bool(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
    }
    c_result = static_cast< bool >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (bool) c_result;
}


Xapian::ValueWeightPostingSource *SwigDirector_ValueWeightPostingSource::clone() const {
  return Xapian::ValueWeightPostingSource::clone();
}


std::string SwigDirector_ValueWeightPostingSource::name() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 9;
    const char *const swig_method_name = "name";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


std::string SwigDirector_ValueWeightPostingSource::serialise() const {
  return Xapian::ValueWeightPostingSource::serialise();
}


Xapian::ValueWeightPostingSource *SwigDirector_ValueWeightPostingSource::unserialise(std::string const &serialised) const {
  return Xapian::ValueWeightPostingSource::unserialise(serialised);
}


Xapian::PostingSource *SwigDirector_ValueWeightPostingSource::unserialise_with_registry(std::string const &serialised,Xapian::Registry const &registry) const {
  return Xapian::PostingSource::unserialise_with_registry(serialised,registry);
}


void SwigDirector_ValueWeightPostingSource::reset(Xapian::Database const &db_,Xapian::doccount shard_index) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&db_), SWIGTYPE_p_Xapian__Database,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(shard_index));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 10;
    const char *const swig_method_name = "reset";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("reset");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_ValueWeightPostingSource::init(Xapian::Database const &db) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&db), SWIGTYPE_p_Xapian__Database,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 11;
    const char *const swig_method_name = "init";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("init");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


std::string SwigDirector_ValueWeightPostingSource::get_description() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ValueWeightPostingSource.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 12;
    const char *const swig_method_name = "__str__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__str__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_MatchSpy::SwigDirector_MatchSpy(PyObject *self): Xapian::MatchSpy(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::MatchSpy *)this, this); 
}




SwigDirector_MatchSpy::~SwigDirector_MatchSpy() {
}

void SwigDirector_MatchSpy::operator ()(Xapian::Document const &doc,double wt) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&doc), SWIGTYPE_p_Xapian__Document,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_From_double(static_cast< double >(wt));
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MatchSpy.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "__call__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__call__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


Xapian::MatchSpy *SwigDirector_MatchSpy::clone() const {
  return Xapian::MatchSpy::clone();
}


std::string SwigDirector_MatchSpy::name() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MatchSpy.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "name";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


std::string SwigDirector_MatchSpy::serialise() const {
  return Xapian::MatchSpy::serialise();
}


Xapian::MatchSpy *SwigDirector_MatchSpy::unserialise(std::string const &serialised,Xapian::Registry const &context) const {
  return Xapian::MatchSpy::unserialise(serialised,context);
}


std::string SwigDirector_MatchSpy::serialise_results() const {
  return Xapian::MatchSpy::serialise_results();
}


void SwigDirector_MatchSpy::merge_results(std::string const &serialised) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    
    obj0 = PyBytes_FromStringAndSize(serialised.data(), serialised.size());
    
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MatchSpy.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char *const swig_method_name = "merge_results";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("merge_results");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


std::string SwigDirector_MatchSpy::get_description() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MatchSpy.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 3;
    const char *const swig_method_name = "__str__";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("__str__");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


SwigDirector_LatLongMetric::SwigDirector_LatLongMetric(PyObject *self): Xapian::LatLongMetric(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Xapian::LatLongMetric *)this, this); 
}




SwigDirector_LatLongMetric::~SwigDirector_LatLongMetric() {
}

double SwigDirector_LatLongMetric::pointwise_distance(Xapian::LatLongCoord const &a,Xapian::LatLongCoord const &b) const {
  double c_result = SwigValueInit< double >() ;
  
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&a), SWIGTYPE_p_Xapian__LatLongCoord,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_Xapian__LatLongCoord,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LatLongMetric.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char *const swig_method_name = "pointwise_distance";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("pointwise_distance");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    double swig_val;
    int swig_res = SWIG_AsVal_double(result, &swig_val);
    if (!SWIG_IsOK(swig_res)) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
    }
    c_result = static_cast< double >(swig_val);
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (double) c_result;
}


Xapian::LatLongMetric *SwigDirector_LatLongMetric::clone() const {
  Xapian::LatLongMetric *c_result = 0 ;
  
  Swig::DirectorPureVirtualException::raise("Attempted to invoke pure virtual method Xapian::LatLongMetric::clone");
  return (Xapian::LatLongMetric *) c_result;
}


std::string SwigDirector_LatLongMetric::name() const {
  std::string c_result;
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LatLongMetric.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char *const swig_method_name = "name";
    PyObject *method = swig_get_method(swig_method_index, swig_method_name);
    swig::SwigVar_PyObject args = PyTuple_New(0);
    swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL);
#else
    swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("name");
    swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if (error != NULL) {
          throw Swig::DirectorMethodException();
        }
      }
    }
    std::string *swig_optr = 0;
    int swig_ores;
    {
      PyObject * tmp = result;
      Py_INCREF(tmp);
      swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
      Py_DECREF(tmp);
    }
    if (!SWIG_IsOK(swig_ores) || !swig_optr) {
      Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
    }
    c_result = *swig_optr;
    if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
  return (std::string) c_result;
}


std::string SwigDirector_LatLongMetric::serialise() const {
  std::string c_result;
  Swig::DirectorPureVirtualException::raise("Attempted to invoke pure virtual method Xapian::LatLongMetric::serialise");
  return (std::string) c_result;
}


Xapian::LatLongMetric *SwigDirector_LatLongMetric::unserialise(std::string const &serialised) const {
  Xapian::LatLongMetric *c_result = 0 ;
  
  Swig::DirectorPureVirtualException::raise("Attempted to invoke pure virtual method Xapian::LatLongMetric::unserialise");
  return (Xapian::LatLongMetric *) c_result;
}


#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->incr(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->incr();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::incr(size_t)\n"
    "    swig::SwigPyIterator::incr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->decr(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->decr();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::decr(size_t)\n"
    "    swig::SwigPyIterator::decr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)(arg1)->next();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)(arg1)->__next__();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (PyObject *)(arg1)->previous();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)(arg1)->advance(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(SWIG_STD_MOVE(arg2));
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Error_get_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Error *arg1 = (Xapian::Error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Error, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_get_type" "', argument " "1"" of type '" "Xapian::Error const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Error * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((Xapian::Error const *)arg1)->get_type();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  
  resultobj = PyBytes_FromString(result);
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Error_get_msg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Error *arg1 = (Xapian::Error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Error, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_get_msg" "', argument " "1"" of type '" "Xapian::Error const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Error * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((Xapian::Error const *)arg1)->get_msg();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Error_get_context(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Error *arg1 = (Xapian::Error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Error, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_get_context" "', argument " "1"" of type '" "Xapian::Error const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Error * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((Xapian::Error const *)arg1)->get_context();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Error_get_error_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Error *arg1 = (Xapian::Error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Error, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error_get_error_string" "', argument " "1"" of type '" "Xapian::Error const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Error * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)((Xapian::Error const *)arg1)->get_error_string();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  
  resultobj = PyBytes_FromString(result);
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Error___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Error *arg1 = (Xapian::Error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Error, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Error___str__" "', argument " "1"" of type '" "Xapian::Error const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Error * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = Xapian_Error___str__((Xapian::Error const *)arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Error(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Error *arg1 = (Xapian::Error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Error, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Error" "', argument " "1"" of type '" "Xapian::Error *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Error * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Error_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Error, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_LogicError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LogicError *arg1 = (Xapian::LogicError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LogicError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogicError" "', argument " "1"" of type '" "Xapian::LogicError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LogicError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogicError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LogicError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_RuntimeError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RuntimeError *arg1 = (Xapian::RuntimeError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RuntimeError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RuntimeError" "', argument " "1"" of type '" "Xapian::RuntimeError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RuntimeError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RuntimeError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__RuntimeError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AssertionError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::AssertionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AssertionError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::AssertionError *)new Xapian::AssertionError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__AssertionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssertionError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::AssertionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AssertionError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::AssertionError *)new Xapian::AssertionError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__AssertionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssertionError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::AssertionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::AssertionError *)new Xapian::AssertionError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__AssertionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssertionError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::AssertionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::AssertionError *)new Xapian::AssertionError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__AssertionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssertionError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::AssertionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AssertionError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::AssertionError *)new Xapian::AssertionError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__AssertionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssertionError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AssertionError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_AssertionError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_AssertionError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_AssertionError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_AssertionError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_AssertionError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AssertionError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::AssertionError::AssertionError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::AssertionError::AssertionError(std::string_view,std::string_view,int)\n"
    "    Xapian::AssertionError::AssertionError(std::string_view,std::string_view)\n"
    "    Xapian::AssertionError::AssertionError(std::string_view)\n"
    "    Xapian::AssertionError::AssertionError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AssertionError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::AssertionError *arg1 = (Xapian::AssertionError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__AssertionError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AssertionError" "', argument " "1"" of type '" "Xapian::AssertionError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::AssertionError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AssertionError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__AssertionError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AssertionError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidArgumentError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::InvalidArgumentError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InvalidArgumentError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidArgumentError *)new Xapian::InvalidArgumentError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::InvalidArgumentError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InvalidArgumentError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidArgumentError *)new Xapian::InvalidArgumentError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::InvalidArgumentError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidArgumentError *)new Xapian::InvalidArgumentError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::InvalidArgumentError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidArgumentError *)new Xapian::InvalidArgumentError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::InvalidArgumentError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InvalidArgumentError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidArgumentError *)new Xapian::InvalidArgumentError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidArgumentError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidArgumentError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidArgumentError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_InvalidArgumentError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidArgumentError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_InvalidArgumentError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_InvalidArgumentError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidArgumentError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view,std::string_view,int)\n"
    "    Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view,std::string_view)\n"
    "    Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view)\n"
    "    Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidArgumentError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::InvalidArgumentError *arg1 = (Xapian::InvalidArgumentError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidArgumentError" "', argument " "1"" of type '" "Xapian::InvalidArgumentError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::InvalidArgumentError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidArgumentError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__InvalidArgumentError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidArgumentError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvalidOperationError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::InvalidOperationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InvalidOperationError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidOperationError *)new Xapian::InvalidOperationError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidOperationError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::InvalidOperationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InvalidOperationError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidOperationError *)new Xapian::InvalidOperationError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidOperationError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::InvalidOperationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidOperationError *)new Xapian::InvalidOperationError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidOperationError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::InvalidOperationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidOperationError *)new Xapian::InvalidOperationError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidOperationError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::InvalidOperationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InvalidOperationError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InvalidOperationError *)new Xapian::InvalidOperationError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidOperationError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvalidOperationError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InvalidOperationError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_InvalidOperationError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InvalidOperationError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_InvalidOperationError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_InvalidOperationError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvalidOperationError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::InvalidOperationError::InvalidOperationError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::InvalidOperationError::InvalidOperationError(std::string_view,std::string_view,int)\n"
    "    Xapian::InvalidOperationError::InvalidOperationError(std::string_view,std::string_view)\n"
    "    Xapian::InvalidOperationError::InvalidOperationError(std::string_view)\n"
    "    Xapian::InvalidOperationError::InvalidOperationError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidOperationError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::InvalidOperationError *arg1 = (Xapian::InvalidOperationError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidOperationError" "', argument " "1"" of type '" "Xapian::InvalidOperationError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::InvalidOperationError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvalidOperationError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__InvalidOperationError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvalidOperationError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UnimplementedError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::UnimplementedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UnimplementedError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::UnimplementedError *)new Xapian::UnimplementedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnimplementedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnimplementedError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::UnimplementedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UnimplementedError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::UnimplementedError *)new Xapian::UnimplementedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnimplementedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnimplementedError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::UnimplementedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::UnimplementedError *)new Xapian::UnimplementedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnimplementedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnimplementedError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::UnimplementedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::UnimplementedError *)new Xapian::UnimplementedError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnimplementedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnimplementedError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::UnimplementedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnimplementedError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::UnimplementedError *)new Xapian::UnimplementedError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnimplementedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnimplementedError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnimplementedError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnimplementedError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_UnimplementedError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnimplementedError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_UnimplementedError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_UnimplementedError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnimplementedError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::UnimplementedError::UnimplementedError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::UnimplementedError::UnimplementedError(std::string_view,std::string_view,int)\n"
    "    Xapian::UnimplementedError::UnimplementedError(std::string_view,std::string_view)\n"
    "    Xapian::UnimplementedError::UnimplementedError(std::string_view)\n"
    "    Xapian::UnimplementedError::UnimplementedError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnimplementedError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::UnimplementedError *arg1 = (Xapian::UnimplementedError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__UnimplementedError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnimplementedError" "', argument " "1"" of type '" "Xapian::UnimplementedError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::UnimplementedError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnimplementedError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__UnimplementedError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UnimplementedError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseError *)new Xapian::DatabaseError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseError *)new Xapian::DatabaseError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseError *)new Xapian::DatabaseError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseError *)new Xapian::DatabaseError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseError *)new Xapian::DatabaseError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseError::DatabaseError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseError::DatabaseError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseError::DatabaseError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseError::DatabaseError(std::string_view)\n"
    "    Xapian::DatabaseError::DatabaseError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseError *arg1 = (Xapian::DatabaseError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseError" "', argument " "1"" of type '" "Xapian::DatabaseError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseCorruptError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseCorruptError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseCorruptError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCorruptError *)new Xapian::DatabaseCorruptError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCorruptError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseCorruptError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseCorruptError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCorruptError *)new Xapian::DatabaseCorruptError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCorruptError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseCorruptError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCorruptError *)new Xapian::DatabaseCorruptError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCorruptError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseCorruptError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCorruptError *)new Xapian::DatabaseCorruptError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCorruptError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseCorruptError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseCorruptError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCorruptError *)new Xapian::DatabaseCorruptError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCorruptError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseCorruptError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseCorruptError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseCorruptError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseCorruptError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseCorruptError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseCorruptError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseCorruptError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view)\n"
    "    Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseCorruptError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseCorruptError *arg1 = (Xapian::DatabaseCorruptError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseCorruptError" "', argument " "1"" of type '" "Xapian::DatabaseCorruptError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseCorruptError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseCorruptError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseCorruptError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseCorruptError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseCreateError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseCreateError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseCreateError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCreateError *)new Xapian::DatabaseCreateError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCreateError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseCreateError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseCreateError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCreateError *)new Xapian::DatabaseCreateError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCreateError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseCreateError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCreateError *)new Xapian::DatabaseCreateError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCreateError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseCreateError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCreateError *)new Xapian::DatabaseCreateError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCreateError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseCreateError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseCreateError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseCreateError *)new Xapian::DatabaseCreateError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseCreateError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseCreateError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseCreateError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseCreateError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseCreateError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseCreateError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseCreateError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseCreateError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view)\n"
    "    Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseCreateError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseCreateError *arg1 = (Xapian::DatabaseCreateError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseCreateError" "', argument " "1"" of type '" "Xapian::DatabaseCreateError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseCreateError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseCreateError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseCreateError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseCreateError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseLockError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseLockError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseLockError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseLockError *)new Xapian::DatabaseLockError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseLockError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseLockError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseLockError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseLockError *)new Xapian::DatabaseLockError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseLockError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseLockError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseLockError *)new Xapian::DatabaseLockError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseLockError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseLockError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseLockError *)new Xapian::DatabaseLockError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseLockError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseLockError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseLockError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseLockError *)new Xapian::DatabaseLockError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseLockError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseLockError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseLockError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseLockError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseLockError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseLockError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseLockError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseLockError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseLockError::DatabaseLockError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseLockError::DatabaseLockError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseLockError::DatabaseLockError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseLockError::DatabaseLockError(std::string_view)\n"
    "    Xapian::DatabaseLockError::DatabaseLockError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseLockError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseLockError *arg1 = (Xapian::DatabaseLockError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseLockError" "', argument " "1"" of type '" "Xapian::DatabaseLockError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseLockError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseLockError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseLockError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseLockError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseModifiedError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseModifiedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseModifiedError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseModifiedError *)new Xapian::DatabaseModifiedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseModifiedError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseModifiedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseModifiedError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseModifiedError *)new Xapian::DatabaseModifiedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseModifiedError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseModifiedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseModifiedError *)new Xapian::DatabaseModifiedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseModifiedError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseModifiedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseModifiedError *)new Xapian::DatabaseModifiedError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseModifiedError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseModifiedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseModifiedError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseModifiedError *)new Xapian::DatabaseModifiedError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseModifiedError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseModifiedError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseModifiedError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseModifiedError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseModifiedError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseModifiedError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseModifiedError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseModifiedError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view)\n"
    "    Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseModifiedError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseModifiedError *arg1 = (Xapian::DatabaseModifiedError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseModifiedError" "', argument " "1"" of type '" "Xapian::DatabaseModifiedError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseModifiedError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseModifiedError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseModifiedError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseModifiedError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseOpeningError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseOpeningError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseOpeningError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseOpeningError *)new Xapian::DatabaseOpeningError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseOpeningError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseOpeningError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseOpeningError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseOpeningError *)new Xapian::DatabaseOpeningError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseOpeningError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseOpeningError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseOpeningError *)new Xapian::DatabaseOpeningError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseOpeningError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseOpeningError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseOpeningError *)new Xapian::DatabaseOpeningError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseOpeningError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseOpeningError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseOpeningError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseOpeningError *)new Xapian::DatabaseOpeningError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseOpeningError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseOpeningError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseOpeningError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseOpeningError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseOpeningError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseOpeningError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseOpeningError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseOpeningError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view)\n"
    "    Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseOpeningError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseOpeningError *arg1 = (Xapian::DatabaseOpeningError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseOpeningError" "', argument " "1"" of type '" "Xapian::DatabaseOpeningError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseOpeningError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseOpeningError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseOpeningError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseOpeningError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseVersionError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseVersionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseVersionError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseVersionError *)new Xapian::DatabaseVersionError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseVersionError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseVersionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseVersionError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseVersionError *)new Xapian::DatabaseVersionError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseVersionError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseVersionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseVersionError *)new Xapian::DatabaseVersionError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseVersionError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseVersionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseVersionError *)new Xapian::DatabaseVersionError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseVersionError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseVersionError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseVersionError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseVersionError *)new Xapian::DatabaseVersionError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseVersionError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseVersionError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseVersionError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseVersionError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseVersionError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseVersionError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseVersionError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseVersionError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view)\n"
    "    Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseVersionError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseVersionError *arg1 = (Xapian::DatabaseVersionError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseVersionError" "', argument " "1"" of type '" "Xapian::DatabaseVersionError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseVersionError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseVersionError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseVersionError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseVersionError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DocNotFoundError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DocNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DocNotFoundError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DocNotFoundError *)new Xapian::DocNotFoundError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DocNotFoundError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DocNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DocNotFoundError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DocNotFoundError *)new Xapian::DocNotFoundError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DocNotFoundError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DocNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DocNotFoundError *)new Xapian::DocNotFoundError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DocNotFoundError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DocNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DocNotFoundError *)new Xapian::DocNotFoundError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DocNotFoundError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DocNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DocNotFoundError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DocNotFoundError *)new Xapian::DocNotFoundError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DocNotFoundError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DocNotFoundError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DocNotFoundError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DocNotFoundError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DocNotFoundError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DocNotFoundError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DocNotFoundError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DocNotFoundError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DocNotFoundError::DocNotFoundError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DocNotFoundError::DocNotFoundError(std::string_view,std::string_view,int)\n"
    "    Xapian::DocNotFoundError::DocNotFoundError(std::string_view,std::string_view)\n"
    "    Xapian::DocNotFoundError::DocNotFoundError(std::string_view)\n"
    "    Xapian::DocNotFoundError::DocNotFoundError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DocNotFoundError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DocNotFoundError *arg1 = (Xapian::DocNotFoundError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DocNotFoundError" "', argument " "1"" of type '" "Xapian::DocNotFoundError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DocNotFoundError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DocNotFoundError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DocNotFoundError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DocNotFoundError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FeatureUnavailableError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::FeatureUnavailableError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FeatureUnavailableError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::FeatureUnavailableError *)new Xapian::FeatureUnavailableError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeatureUnavailableError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::FeatureUnavailableError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FeatureUnavailableError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::FeatureUnavailableError *)new Xapian::FeatureUnavailableError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeatureUnavailableError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::FeatureUnavailableError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::FeatureUnavailableError *)new Xapian::FeatureUnavailableError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeatureUnavailableError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::FeatureUnavailableError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::FeatureUnavailableError *)new Xapian::FeatureUnavailableError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeatureUnavailableError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::FeatureUnavailableError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FeatureUnavailableError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::FeatureUnavailableError *)new Xapian::FeatureUnavailableError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeatureUnavailableError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FeatureUnavailableError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_FeatureUnavailableError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_FeatureUnavailableError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_FeatureUnavailableError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_FeatureUnavailableError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_FeatureUnavailableError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FeatureUnavailableError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view,std::string_view,int)\n"
    "    Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view,std::string_view)\n"
    "    Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view)\n"
    "    Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FeatureUnavailableError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::FeatureUnavailableError *arg1 = (Xapian::FeatureUnavailableError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FeatureUnavailableError" "', argument " "1"" of type '" "Xapian::FeatureUnavailableError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::FeatureUnavailableError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FeatureUnavailableError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__FeatureUnavailableError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FeatureUnavailableError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InternalError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::InternalError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InternalError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InternalError *)new Xapian::InternalError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InternalError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InternalError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::InternalError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InternalError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InternalError *)new Xapian::InternalError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InternalError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InternalError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::InternalError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InternalError *)new Xapian::InternalError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InternalError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InternalError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::InternalError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InternalError *)new Xapian::InternalError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InternalError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InternalError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::InternalError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InternalError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::InternalError *)new Xapian::InternalError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InternalError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InternalError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InternalError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InternalError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_InternalError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_InternalError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_InternalError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_InternalError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InternalError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::InternalError::InternalError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::InternalError::InternalError(std::string_view,std::string_view,int)\n"
    "    Xapian::InternalError::InternalError(std::string_view,std::string_view)\n"
    "    Xapian::InternalError::InternalError(std::string_view)\n"
    "    Xapian::InternalError::InternalError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InternalError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::InternalError *arg1 = (Xapian::InternalError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__InternalError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InternalError" "', argument " "1"" of type '" "Xapian::InternalError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::InternalError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InternalError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__InternalError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InternalError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NetworkError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::NetworkError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NetworkError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkError *)new Xapian::NetworkError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::NetworkError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NetworkError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkError *)new Xapian::NetworkError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::NetworkError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkError *)new Xapian::NetworkError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::NetworkError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkError *)new Xapian::NetworkError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::NetworkError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NetworkError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkError *)new Xapian::NetworkError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NetworkError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NetworkError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_NetworkError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NetworkError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_NetworkError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_NetworkError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NetworkError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::NetworkError::NetworkError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::NetworkError::NetworkError(std::string_view,std::string_view,int)\n"
    "    Xapian::NetworkError::NetworkError(std::string_view,std::string_view)\n"
    "    Xapian::NetworkError::NetworkError(std::string_view)\n"
    "    Xapian::NetworkError::NetworkError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetworkError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::NetworkError *arg1 = (Xapian::NetworkError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__NetworkError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetworkError" "', argument " "1"" of type '" "Xapian::NetworkError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::NetworkError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetworkError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__NetworkError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NetworkError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NetworkTimeoutError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::NetworkTimeoutError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NetworkTimeoutError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkTimeoutError *)new Xapian::NetworkTimeoutError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkTimeoutError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::NetworkTimeoutError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NetworkTimeoutError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkTimeoutError *)new Xapian::NetworkTimeoutError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkTimeoutError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::NetworkTimeoutError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkTimeoutError *)new Xapian::NetworkTimeoutError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkTimeoutError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::NetworkTimeoutError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkTimeoutError *)new Xapian::NetworkTimeoutError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkTimeoutError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::NetworkTimeoutError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NetworkTimeoutError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::NetworkTimeoutError *)new Xapian::NetworkTimeoutError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkTimeoutError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NetworkTimeoutError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NetworkTimeoutError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_NetworkTimeoutError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NetworkTimeoutError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_NetworkTimeoutError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_NetworkTimeoutError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NetworkTimeoutError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view,std::string_view,int)\n"
    "    Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view,std::string_view)\n"
    "    Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view)\n"
    "    Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetworkTimeoutError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::NetworkTimeoutError *arg1 = (Xapian::NetworkTimeoutError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetworkTimeoutError" "', argument " "1"" of type '" "Xapian::NetworkTimeoutError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::NetworkTimeoutError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetworkTimeoutError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__NetworkTimeoutError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NetworkTimeoutError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QueryParserError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::QueryParserError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_QueryParserError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::QueryParserError *)new Xapian::QueryParserError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__QueryParserError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QueryParserError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::QueryParserError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QueryParserError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::QueryParserError *)new Xapian::QueryParserError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__QueryParserError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QueryParserError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::QueryParserError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::QueryParserError *)new Xapian::QueryParserError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__QueryParserError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QueryParserError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::QueryParserError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::QueryParserError *)new Xapian::QueryParserError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__QueryParserError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QueryParserError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::QueryParserError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QueryParserError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::QueryParserError *)new Xapian::QueryParserError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__QueryParserError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QueryParserError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QueryParserError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_QueryParserError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_QueryParserError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_QueryParserError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_QueryParserError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_QueryParserError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QueryParserError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParserError::QueryParserError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::QueryParserError::QueryParserError(std::string_view,std::string_view,int)\n"
    "    Xapian::QueryParserError::QueryParserError(std::string_view,std::string_view)\n"
    "    Xapian::QueryParserError::QueryParserError(std::string_view)\n"
    "    Xapian::QueryParserError::QueryParserError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QueryParserError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParserError *arg1 = (Xapian::QueryParserError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParserError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QueryParserError" "', argument " "1"" of type '" "Xapian::QueryParserError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParserError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QueryParserError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__QueryParserError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QueryParserError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SerialisationError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::SerialisationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SerialisationError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::SerialisationError *)new Xapian::SerialisationError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SerialisationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SerialisationError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::SerialisationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SerialisationError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::SerialisationError *)new Xapian::SerialisationError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SerialisationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SerialisationError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::SerialisationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::SerialisationError *)new Xapian::SerialisationError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SerialisationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SerialisationError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::SerialisationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::SerialisationError *)new Xapian::SerialisationError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SerialisationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SerialisationError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::SerialisationError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SerialisationError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::SerialisationError *)new Xapian::SerialisationError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SerialisationError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SerialisationError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SerialisationError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_SerialisationError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_SerialisationError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_SerialisationError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_SerialisationError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_SerialisationError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SerialisationError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::SerialisationError::SerialisationError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::SerialisationError::SerialisationError(std::string_view,std::string_view,int)\n"
    "    Xapian::SerialisationError::SerialisationError(std::string_view,std::string_view)\n"
    "    Xapian::SerialisationError::SerialisationError(std::string_view)\n"
    "    Xapian::SerialisationError::SerialisationError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SerialisationError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::SerialisationError *arg1 = (Xapian::SerialisationError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__SerialisationError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SerialisationError" "', argument " "1"" of type '" "Xapian::SerialisationError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::SerialisationError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SerialisationError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__SerialisationError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SerialisationError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RangeError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::RangeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RangeError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::RangeError *)new Xapian::RangeError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::RangeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RangeError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::RangeError *)new Xapian::RangeError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::RangeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::RangeError *)new Xapian::RangeError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::RangeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::RangeError *)new Xapian::RangeError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::RangeError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RangeError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::RangeError *)new Xapian::RangeError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RangeError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_RangeError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_RangeError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_RangeError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_RangeError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_RangeError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RangeError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::RangeError::RangeError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::RangeError::RangeError(std::string_view,std::string_view,int)\n"
    "    Xapian::RangeError::RangeError(std::string_view,std::string_view)\n"
    "    Xapian::RangeError::RangeError(std::string_view)\n"
    "    Xapian::RangeError::RangeError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RangeError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RangeError *arg1 = (Xapian::RangeError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RangeError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RangeError" "', argument " "1"" of type '" "Xapian::RangeError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RangeError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RangeError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__RangeError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RangeError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_WildcardError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::WildcardError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_WildcardError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::WildcardError *)new Xapian::WildcardError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WildcardError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WildcardError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::WildcardError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_WildcardError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::WildcardError *)new Xapian::WildcardError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WildcardError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WildcardError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::WildcardError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::WildcardError *)new Xapian::WildcardError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WildcardError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WildcardError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::WildcardError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::WildcardError *)new Xapian::WildcardError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WildcardError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WildcardError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::WildcardError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_WildcardError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::WildcardError *)new Xapian::WildcardError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WildcardError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WildcardError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_WildcardError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_WildcardError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_WildcardError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_WildcardError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_WildcardError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_WildcardError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WildcardError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WildcardError::WildcardError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::WildcardError::WildcardError(std::string_view,std::string_view,int)\n"
    "    Xapian::WildcardError::WildcardError(std::string_view,std::string_view)\n"
    "    Xapian::WildcardError::WildcardError(std::string_view)\n"
    "    Xapian::WildcardError::WildcardError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WildcardError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WildcardError *arg1 = (Xapian::WildcardError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WildcardError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WildcardError" "', argument " "1"" of type '" "Xapian::WildcardError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WildcardError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WildcardError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__WildcardError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *WildcardError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseNotFoundError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseNotFoundError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseNotFoundError *)new Xapian::DatabaseNotFoundError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseNotFoundError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseNotFoundError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseNotFoundError *)new Xapian::DatabaseNotFoundError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseNotFoundError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseNotFoundError *)new Xapian::DatabaseNotFoundError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseNotFoundError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseNotFoundError *)new Xapian::DatabaseNotFoundError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseNotFoundError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseNotFoundError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseNotFoundError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseNotFoundError *)new Xapian::DatabaseNotFoundError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseNotFoundError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseNotFoundError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseNotFoundError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseNotFoundError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseNotFoundError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseNotFoundError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseNotFoundError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseNotFoundError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view)\n"
    "    Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseNotFoundError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseNotFoundError *arg1 = (Xapian::DatabaseNotFoundError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseNotFoundError" "', argument " "1"" of type '" "Xapian::DatabaseNotFoundError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseNotFoundError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseNotFoundError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseNotFoundError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseNotFoundError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatabaseClosedError__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  Xapian::DatabaseClosedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatabaseClosedError" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseClosedError *)new Xapian::DatabaseClosedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),(char const *)arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseClosedError__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DatabaseClosedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DatabaseClosedError" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseClosedError *)new Xapian::DatabaseClosedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseClosedError__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::DatabaseClosedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseClosedError *)new Xapian::DatabaseClosedError(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseClosedError__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::DatabaseClosedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseClosedError *)new Xapian::DatabaseClosedError(SWIG_STD_MOVE(arg1));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseClosedError__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::DatabaseClosedError *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DatabaseClosedError" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::DatabaseClosedError *)new Xapian::DatabaseClosedError(SWIG_STD_MOVE(arg1),arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatabaseClosedError(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatabaseClosedError", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DatabaseClosedError__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DatabaseClosedError__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DatabaseClosedError__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DatabaseClosedError__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DatabaseClosedError__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatabaseClosedError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view,std::string_view,char const *)\n"
    "    Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view,std::string_view,int)\n"
    "    Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view,std::string_view)\n"
    "    Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view)\n"
    "    Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatabaseClosedError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DatabaseClosedError *arg1 = (Xapian::DatabaseClosedError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatabaseClosedError" "', argument " "1"" of type '" "Xapian::DatabaseClosedError *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DatabaseClosedError * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatabaseClosedError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DatabaseClosedError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatabaseClosedError_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_version_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "version_string", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (char *)Xapian::version_string();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  
  resultobj = PyUnicode_FromString(result);
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_major_version(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "major_version", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)Xapian::major_version();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minor_version(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "minor_version", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)Xapian::minor_version();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_revision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "revision", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)Xapian::revision();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__PositionIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__PositionIterator", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::PositionIterator *)new Xapian::PositionIterator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__PositionIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__PositionIterator" "', argument " "1"" of type '" "Xapian::PositionIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PositionIterator_skip_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::termpos arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PositionIterator_skip_to", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator_skip_to" "', argument " "1"" of type '" "Xapian::PositionIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_PositionIterator_skip_to" "', argument " "2"" of type '" "Xapian::termpos""'");
  } 
  arg2 = static_cast< Xapian::termpos >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->skip_to(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PositionIterator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator___str__" "', argument " "1"" of type '" "Xapian::PositionIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::PositionIterator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PositionIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::PositionIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PositionIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator___eq__" "', argument " "1"" of type '" "Xapian::PositionIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_PositionIterator___eq__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_PositionIterator___eq__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PositionIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_PositionIterator___eq__(arg1,(Xapian::PositionIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__PositionIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::PositionIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PositionIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator___ne__" "', argument " "1"" of type '" "Xapian::PositionIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_PositionIterator___ne__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_PositionIterator___ne__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PositionIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_PositionIterator___ne__(arg1,(Xapian::PositionIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__PositionIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::PositionIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PositionIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator_equals" "', argument " "1"" of type '" "Xapian::PositionIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_PositionIterator_equals" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_PositionIterator_equals" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PositionIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_PositionIterator_equals((Xapian::PositionIterator const *)arg1,(Xapian::PositionIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PositionIterator_get_termpos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termpos result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator_get_termpos" "', argument " "1"" of type '" "Xapian::PositionIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termpos)Xapian_PositionIterator_get_termpos((Xapian::PositionIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PositionIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PositionIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PositionIterator___next__" "', argument " "1"" of type '" "Xapian::PositionIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_PositionIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_PositionIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__PositionIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_PositionIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = 0 ;
  Xapian::PositionIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PositionIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator ==((Xapian::PositionIterator const &)*arg1,(Xapian::PositionIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::PositionIterator *arg1 = 0 ;
  Xapian::PositionIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PositionIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PositionIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::PositionIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PositionIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::PositionIterator const &)*arg1,(Xapian::PositionIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new__PostingIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__PostingIterator", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::PostingIterator *)new Xapian::PostingIterator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__PostingIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__PostingIterator" "', argument " "1"" of type '" "Xapian::PostingIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator_get_wdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_get_wdf" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::PostingIterator const *)arg1)->get_wdf();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator_get_doclength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_get_doclength" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::PostingIterator const *)arg1)->get_doclength();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator_get_unique_terms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_get_unique_terms" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::PostingIterator const *)arg1)->get_unique_terms();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator_get_wdfdocmax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_get_wdfdocmax" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::PostingIterator const *)arg1)->get_wdfdocmax();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator__positionlist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::PositionIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator__positionlist_begin" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::PostingIterator const *)arg1)->positionlist_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PositionIterator(result)), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator__positionlist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::PositionIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator__positionlist_end" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::PostingIterator const *)arg1)->positionlist_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PositionIterator(result)), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator_skip_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PostingIterator_skip_to", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_skip_to" "', argument " "1"" of type '" "Xapian::PostingIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_PostingIterator_skip_to" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->skip_to(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator___str__" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::PostingIterator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PostingIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PostingIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator___eq__" "', argument " "1"" of type '" "Xapian::PostingIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_PostingIterator___eq__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_PostingIterator___eq__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PostingIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_PostingIterator___eq__(arg1,(Xapian::PostingIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__PostingIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PostingIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PostingIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator___ne__" "', argument " "1"" of type '" "Xapian::PostingIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_PostingIterator___ne__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_PostingIterator___ne__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PostingIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_PostingIterator___ne__(arg1,(Xapian::PostingIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__PostingIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PostingIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_PostingIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_equals" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_PostingIterator_equals" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_PostingIterator_equals" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PostingIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_PostingIterator_equals((Xapian::PostingIterator const *)arg1,(Xapian::PostingIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator_get_docid" "', argument " "1"" of type '" "Xapian::PostingIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)Xapian_PostingIterator_get_docid((Xapian::PostingIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__PostingIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_PostingIterator___next__" "', argument " "1"" of type '" "Xapian::PostingIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_PostingIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_PostingIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__PostingIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_PostingIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = 0 ;
  Xapian::PostingIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PostingIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator ==((Xapian::PostingIterator const &)*arg1,(Xapian::PostingIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::PostingIterator *arg1 = 0 ;
  Xapian::PostingIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PostingIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::PostingIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PostingIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::PostingIterator const &)*arg1,(Xapian::PostingIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new__TermIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__TermIterator", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::TermIterator *)new Xapian::TermIterator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__TermIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__TermIterator" "', argument " "1"" of type '" "Xapian::TermIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator_get_wdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator_get_wdf" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::TermIterator const *)arg1)->get_wdf();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator_get_termfreq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator_get_termfreq" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::TermIterator const *)arg1)->get_termfreq();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator_positionlist_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator_positionlist_count" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::TermIterator const *)arg1)->positionlist_count();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator__positionlist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::PositionIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator__positionlist_begin" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::TermIterator const *)arg1)->positionlist_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PositionIterator(result)), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator__positionlist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::PositionIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator__positionlist_end" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::TermIterator const *)arg1)->positionlist_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PositionIterator(result)), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator_skip_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_TermIterator_skip_to", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator_skip_to" "', argument " "1"" of type '" "Xapian::TermIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->skip_to(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator___str__" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::TermIterator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::TermIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_TermIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator___eq__" "', argument " "1"" of type '" "Xapian::TermIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_TermIterator___eq__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_TermIterator___eq__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::TermIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_TermIterator___eq__(arg1,(Xapian::TermIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__TermIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::TermIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_TermIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator___ne__" "', argument " "1"" of type '" "Xapian::TermIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_TermIterator___ne__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_TermIterator___ne__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::TermIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_TermIterator___ne__(arg1,(Xapian::TermIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__TermIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::TermIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_TermIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator_equals" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_TermIterator_equals" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_TermIterator_equals" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::TermIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_TermIterator_equals((Xapian::TermIterator const *)arg1,(Xapian::TermIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator_get_term(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator_get_term" "', argument " "1"" of type '" "Xapian::TermIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian_TermIterator_get_term((Xapian::TermIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__TermIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_TermIterator___next__" "', argument " "1"" of type '" "Xapian::TermIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_TermIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_TermIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__TermIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_TermIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___eq____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = 0 ;
  Xapian::TermIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::TermIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator ==((Xapian::TermIterator const &)*arg1,(Xapian::TermIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermIterator *arg1 = 0 ;
  Xapian::TermIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__TermIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::TermIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::TermIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::TermIterator const &)*arg1,(Xapian::TermIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new__ValueIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__ValueIterator", 0, 0, 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::ValueIterator *)new Xapian::ValueIterator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__ValueIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__ValueIterator" "', argument " "1"" of type '" "Xapian::ValueIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator_get_docid" "', argument " "1"" of type '" "Xapian::ValueIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)((Xapian::ValueIterator const *)arg1)->get_docid();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator_get_valueno(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::valueno result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator_get_valueno" "', argument " "1"" of type '" "Xapian::ValueIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::valueno)((Xapian::ValueIterator const *)arg1)->get_valueno();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator_skip_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ValueIterator_skip_to", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator_skip_to" "', argument " "1"" of type '" "Xapian::ValueIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ValueIterator_skip_to" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->skip_to(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ValueIterator_check", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator_check" "', argument " "1"" of type '" "Xapian::ValueIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ValueIterator_check" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)(arg1)->check(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator___str__" "', argument " "1"" of type '" "Xapian::ValueIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ValueIterator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::ValueIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ValueIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator___eq__" "', argument " "1"" of type '" "Xapian::ValueIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ValueIterator___eq__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ValueIterator___eq__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ValueIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_ValueIterator___eq__(arg1,(Xapian::ValueIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__ValueIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::ValueIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ValueIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator___ne__" "', argument " "1"" of type '" "Xapian::ValueIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ValueIterator___ne__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ValueIterator___ne__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ValueIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_ValueIterator___ne__(arg1,(Xapian::ValueIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__ValueIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::ValueIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ValueIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator_equals" "', argument " "1"" of type '" "Xapian::ValueIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ValueIterator_equals" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ValueIterator_equals" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ValueIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_ValueIterator_equals((Xapian::ValueIterator const *)arg1,(Xapian::ValueIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator_get_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator_get_value" "', argument " "1"" of type '" "Xapian::ValueIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian_ValueIterator_get_value((Xapian::ValueIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ValueIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ValueIterator___next__" "', argument " "1"" of type '" "Xapian::ValueIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_ValueIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_ValueIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ValueIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_ValueIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___eq____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = 0 ;
  Xapian::ValueIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ValueIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator ==((Xapian::ValueIterator const &)*arg1,(Xapian::ValueIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ValueIterator *arg1 = 0 ;
  Xapian::ValueIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ValueIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::ValueIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ValueIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::ValueIterator const &)*arg1,(Xapian::ValueIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_Document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Document", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Document *)new Xapian::Document();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Document, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_get_docid" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)((Xapian::Document const *)arg1)->get_docid();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_get_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_get_data" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Document const *)arg1)->get_data();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_set_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Document_set_data", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_set_data" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_data(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_term__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_add_term" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_add_term" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_term(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_term__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_add_term" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_term(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_term(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Document_add_term", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Document_add_term__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Document_add_term__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Document_add_term'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Document::add_term(std::string_view,Xapian::termcount)\n"
    "    Xapian::Document::add_term(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Document_add_boolean_term(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Document_add_boolean_term", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_add_boolean_term" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_term(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_remove_term(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Document_remove_term", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_remove_term" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_term(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_posting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termpos arg3 ;
  Xapian::termcount arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_add_posting" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_add_posting" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_add_posting" "', argument " "4"" of type '" "Xapian::termcount""'");
  } 
  arg4 = static_cast< Xapian::termcount >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_posting(SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_posting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termpos arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_add_posting" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_add_posting" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_posting(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_posting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Document_add_posting", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Document_add_posting__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Document_add_posting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Document_add_posting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Document::add_posting(std::string_view,Xapian::termpos,Xapian::termcount)\n"
    "    Xapian::Document::add_posting(std::string_view,Xapian::termpos)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Document_remove_posting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termpos arg3 ;
  Xapian::termcount arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_remove_posting" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_remove_posting" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_remove_posting" "', argument " "4"" of type '" "Xapian::termcount""'");
  } 
  arg4 = static_cast< Xapian::termcount >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_posting(SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_remove_posting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termpos arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_remove_posting" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_remove_posting" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_posting(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_remove_posting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Document_remove_posting", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Document_remove_posting__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Document_remove_posting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Document_remove_posting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Document::remove_posting(std::string_view,Xapian::termpos,Xapian::termcount)\n"
    "    Xapian::Document::remove_posting(std::string_view,Xapian::termpos)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Document_remove_postings__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termpos arg3 ;
  Xapian::termpos arg4 ;
  Xapian::termcount arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  Xapian::termpos result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_remove_postings" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_remove_postings" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_remove_postings" "', argument " "4"" of type '" "Xapian::termpos""'");
  } 
  arg4 = static_cast< Xapian::termpos >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_remove_postings" "', argument " "5"" of type '" "Xapian::termcount""'");
  } 
  arg5 = static_cast< Xapian::termcount >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termpos)(arg1)->remove_postings(SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_remove_postings__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string_view arg2 ;
  Xapian::termpos arg3 ;
  Xapian::termpos arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Xapian::termpos result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_remove_postings" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_remove_postings" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_remove_postings" "', argument " "4"" of type '" "Xapian::termpos""'");
  } 
  arg4 = static_cast< Xapian::termpos >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termpos)(arg1)->remove_postings(SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_remove_postings(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Document_remove_postings", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_Document_remove_postings__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Document_remove_postings__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Document_remove_postings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Document::remove_postings(std::string_view,Xapian::termpos,Xapian::termpos,Xapian::termcount)\n"
    "    Xapian::Document::remove_postings(std::string_view,Xapian::termpos,Xapian::termpos)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Document_clear_terms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clear_terms" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->clear_terms();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_termlist_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_termlist_count" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Document const *)arg1)->termlist_count();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document__termlist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document__termlist_begin" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Document const *)arg1)->termlist_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document__termlist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document__termlist_end" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Document const *)arg1)->termlist_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_get_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Document_get_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_get_value" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_get_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Document const *)arg1)->get_value(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_add_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::valueno arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Document_add_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_add_value" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_add_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_value(arg2,SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_remove_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Document_remove_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_remove_value" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_remove_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_value(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_clear_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clear_values" "', argument " "1"" of type '" "Xapian::Document *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->clear_values();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_values_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::valueno result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_values_count" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::valueno)((Xapian::Document const *)arg1)->values_count();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document__values_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ValueIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document__values_begin" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Document const *)arg1)->values_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ValueIterator(result)), SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document__values_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ValueIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document__values_end" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Document const *)arg1)->values_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ValueIterator(result)), SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_serialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_serialise" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Document const *)arg1)->serialise();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document_unserialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *swig_obj[1] ;
  Xapian::Document result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[0], &p, &len) < 0) SWIG_fail;
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Document::unserialise(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Document(result)), SWIGTYPE_p_Xapian__Document, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Document___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Document, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document___str__" "', argument " "1"" of type '" "Xapian::Document const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Document * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Document const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Document, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Document_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Registry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_Registry", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Registry *)new Xapian::Registry();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Registry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Registry(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Registry" "', argument " "1"" of type '" "Xapian::Registry *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_register_weighting_scheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  Xapian::Weight *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_register_weighting_scheme", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_register_weighting_scheme" "', argument " "1"" of type '" "Xapian::Registry *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Weight,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Registry_register_weighting_scheme" "', argument " "2"" of type '" "Xapian::Weight const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Registry_register_weighting_scheme" "', argument " "2"" of type '" "Xapian::Weight const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Weight * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->register_weighting_scheme((Xapian::Weight const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_get_weighting_scheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_get_weighting_scheme", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_get_weighting_scheme" "', argument " "1"" of type '" "Xapian::Registry const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Weight *)((Xapian::Registry const *)arg1)->get_weighting_scheme(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_register_posting_source(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  Xapian::PostingSource *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_register_posting_source", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_register_posting_source" "', argument " "1"" of type '" "Xapian::Registry *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__PostingSource,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Registry_register_posting_source" "', argument " "2"" of type '" "Xapian::PostingSource const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Registry_register_posting_source" "', argument " "2"" of type '" "Xapian::PostingSource const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::PostingSource * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->register_posting_source((Xapian::PostingSource const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_get_posting_source(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::PostingSource *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_get_posting_source", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_get_posting_source" "', argument " "1"" of type '" "Xapian::Registry const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PostingSource *)((Xapian::Registry const *)arg1)->get_posting_source(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_register_match_spy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  Xapian::MatchSpy *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_register_match_spy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_register_match_spy" "', argument " "1"" of type '" "Xapian::Registry *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MatchSpy,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Registry_register_match_spy" "', argument " "2"" of type '" "Xapian::MatchSpy const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Registry_register_match_spy" "', argument " "2"" of type '" "Xapian::MatchSpy const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MatchSpy * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->register_match_spy((Xapian::MatchSpy const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_get_match_spy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::MatchSpy *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_get_match_spy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_get_match_spy" "', argument " "1"" of type '" "Xapian::Registry const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::MatchSpy *)((Xapian::Registry const *)arg1)->get_match_spy(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_register_lat_long_metric(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  Xapian::LatLongMetric *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_register_lat_long_metric", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_register_lat_long_metric" "', argument " "1"" of type '" "Xapian::Registry *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Registry_register_lat_long_metric" "', argument " "2"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Registry_register_lat_long_metric" "', argument " "2"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongMetric * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->register_lat_long_metric((Xapian::LatLongMetric const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_get_lat_long_metric(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::LatLongMetric *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_get_lat_long_metric", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_get_lat_long_metric" "', argument " "1"" of type '" "Xapian::Registry const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongMetric *)((Xapian::Registry const *)arg1)->get_lat_long_metric(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_register_key_maker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  Xapian::KeyMaker *arg2 = (Xapian::KeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_register_key_maker", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_register_key_maker" "', argument " "1"" of type '" "Xapian::Registry *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Registry_register_key_maker" "', argument " "2"" of type '" "Xapian::KeyMaker *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::KeyMaker * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->register_key_maker(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Registry_get_key_maker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Registry *arg1 = (Xapian::Registry *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::KeyMaker *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Registry_get_key_maker", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Registry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Registry_get_key_maker" "', argument " "1"" of type '" "Xapian::Registry const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Registry * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::KeyMaker *)((Xapian::Registry const *)arg1)->get_key_maker(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *Registry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Registry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Registry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Query__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::Query *)new Xapian::Query();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Query(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Query" "', argument " "1"" of type '" "Xapian::Query *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  Xapian::termcount arg2 ;
  Xapian::termpos arg3 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::termpos""'");
  } 
  arg3 = static_cast< Xapian::termpos >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(SWIG_STD_MOVE(arg1),arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  Xapian::termcount arg2 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  Xapian::Query *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Query,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Query * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,(Xapian::Query const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  Xapian::Query *arg2 = 0 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Query,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Query * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,(Xapian::Query const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  Xapian::Query *arg2 = 0 ;
  Xapian::Query *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Query,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Query * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__Query,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::Query const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::Query const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::Query * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,(Xapian::Query const &)*arg2,(Xapian::Query const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  Xapian::valueno arg2 ;
  std::string_view arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,arg2,SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  Xapian::valueno arg2 ;
  std::string_view arg3 ;
  std::string_view arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  PyObject *bytes4 = NULL ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Query" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  int arg4 ;
  Xapian::Query::op arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Query" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Query" "', argument " "5"" of type '" "Xapian::Query::op""'");
  } 
  arg5 = static_cast< Xapian::Query::op >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Query" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  int arg4 ;
  Xapian::Query::op arg5 ;
  unsigned int arg6 ;
  size_t arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Query" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Query" "', argument " "5"" of type '" "Xapian::Query::op""'");
  } 
  arg5 = static_cast< Xapian::Query::op >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Query" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Query" "', argument " "7"" of type '" "size_t""'");
  } 
  arg7 = static_cast< size_t >(val7);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  int arg4 ;
  Xapian::Query::op arg5 ;
  unsigned int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Query" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Query" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Query" "', argument " "5"" of type '" "Xapian::Query::op""'");
  } 
  arg5 = static_cast< Xapian::Query::op >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Query" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  XapianSWIGQueryItor arg2 ;
  XapianSWIGQueryItor arg3 ;
  Xapian::termcount arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    PyObject * seq;
    seq = PySequence_Fast(swig_obj[1],
      "expected sequence of Query objects and/or strings");
    if (!seq) SWIG_fail;
    (&arg2)->begin(seq);
    (&arg3)->end(seq);
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Query" "', argument " "4"" of type '" "Xapian::termcount""'");
  } 
  arg4 = static_cast< Xapian::termcount >(val4);
  {
    try {
      result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  (&arg2)->free_seq(); 
  return resultobj;
fail:
  (&arg2)->free_seq(); 
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  XapianSWIGQueryItor arg2 ;
  XapianSWIGQueryItor arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    PyObject * seq;
    seq = PySequence_Fast(swig_obj[1],
      "expected sequence of Query objects and/or strings");
    if (!seq) SWIG_fail;
    (&arg2)->begin(seq);
    (&arg3)->end(seq);
  }
  {
    try {
      result = (Xapian::Query *)new Xapian::Query(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  (&arg2)->free_seq(); 
  return resultobj;
fail:
  (&arg2)->free_seq(); 
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query__get_terms_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query__get_terms_begin" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Query const *)arg1)->get_terms_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query__get_terms_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query__get_terms_end" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Query const *)arg1)->get_terms_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_unique_terms_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_unique_terms_begin" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Query const *)arg1)->get_unique_terms_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_unique_terms_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_unique_terms_end" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Query const *)arg1)->get_unique_terms_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_length" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::termcount)((Xapian::Query const *)arg1)->get_length();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_empty" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((Xapian::Query const *)arg1)->empty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_serialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_serialise" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Query const *)arg1)->serialise();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_unserialise__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  Xapian::Registry *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::Query result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[0], &p, &len) < 0) SWIG_fail;
    arg1 = std::string_view(p, len);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Registry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Query_unserialise" "', argument " "2"" of type '" "Xapian::Registry const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Query_unserialise" "', argument " "2"" of type '" "Xapian::Registry const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Registry * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Query::unserialise(SWIG_STD_MOVE(arg1),(Xapian::Registry const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_unserialise__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  Xapian::Query result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[0], &p, &len) < 0) SWIG_fail;
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Query::unserialise(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_unserialise(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Query_unserialise", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Query_unserialise__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Query_unserialise__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Query_unserialise'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Query::unserialise(std::string_view,Xapian::Registry const &)\n"
    "    Xapian::Query::unserialise(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Query_get_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Query::op result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_type" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::Query::op)((Xapian::Query const *)arg1)->get_type();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_num_subqueries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_num_subqueries" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Query const *)arg1)->get_num_subqueries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_leaf_wqf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_leaf_wqf" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Query const *)arg1)->get_leaf_wqf();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_leaf_pos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termpos result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_leaf_pos" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termpos)((Xapian::Query const *)arg1)->get_leaf_pos();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query_get_subquery(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::Query result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Query_get_subquery", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_get_subquery" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Query_get_subquery" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Query const *)arg1)->get_subquery(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Query___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Query, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query___str__" "', argument " "1"" of type '" "Xapian::Query const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Query * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Query const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new Xapian::Query(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Query::op arg1 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Query" "', argument " "1"" of type '" "Xapian::Query::op""'");
  } 
  arg1 = static_cast< Xapian::Query::op >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *)new_Xapian_Query__SWIG_19(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Query(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Query", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_Query__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Xapian__PostingSource, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_Query__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_new_Query__SWIG_18(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Query__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    if (!_v) goto check_5;
    return _wrap_new_Query__SWIG_13(self, argc, argv);
  }
check_5:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_6;
    {
      {
        // Checking for a sequence which isn't a string or bytes is enough to
        // disambiguate currently.
        _v = (PySequence_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) &&
          !PyBytes_Check(argv[1]));
      }
    }
    if (!_v) goto check_6;
    return _wrap_new_Query__SWIG_17(self, argc, argv);
  }
check_6:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_double(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_7;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_7;
    return _wrap_new_Query__SWIG_5(self, argc, argv);
  }
check_7:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Query__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_9;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_9;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_9;
    return _wrap_new_Query__SWIG_7(self, argc, argv);
  }
check_9:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_10;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__Query, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_10;
    {
      {
        int res = SWIG_AsVal_double(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_10;
    return _wrap_new_Query__SWIG_6(self, argc, argv);
  }
check_10:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_11;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_11;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[2]);
#else
      _v = PyUnicode_Check(argv[2]) || PyBytes_Check(argv[2]);
#endif
    }
    if (!_v) goto check_11;
    return _wrap_new_Query__SWIG_8(self, argc, argv);
  }
check_11:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_12;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    if (!_v) goto check_12;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_12;
    return _wrap_new_Query__SWIG_12(self, argc, argv);
  }
check_12:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_13;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[1]);
#else
      _v = PyUnicode_Check(argv[1]) || PyBytes_Check(argv[1]);
#endif
    }
    if (!_v) goto check_13;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[2]);
#else
      _v = PyUnicode_Check(argv[2]) || PyBytes_Check(argv[2]);
#endif
    }
    if (!_v) goto check_13;
    return _wrap_new_Query__SWIG_19(self, argc, argv);
  }
check_13:
  
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_14;
    {
      {
        // Checking for a sequence which isn't a string or bytes is enough to
        // disambiguate currently.
        _v = (PySequence_Check(argv[1]) &&
          !PyUnicode_Check(argv[1]) &&
          !PyBytes_Check(argv[1]));
      }
    }
    if (!_v) goto check_14;
    PyObject *retobj = _wrap_new_Query__SWIG_16(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_14:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_Query__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_16;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[2]);
#else
      _v = PyUnicode_Check(argv[2]) || PyBytes_Check(argv[2]);
#endif
    }
    if (!_v) goto check_16;
    {
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
      _v = PyBytes_Check(argv[3]);
#else
      _v = PyUnicode_Check(argv[3]) || PyBytes_Check(argv[3]);
#endif
    }
    if (!_v) goto check_16;
    return _wrap_new_Query__SWIG_9(self, argc, argv);
  }
check_16:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_Query__SWIG_11(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_Query__SWIG_10(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_Query__SWIG_15(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_new_Query__SWIG_14(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Query'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Query::Query()\n"
    "    Xapian::Query::Query(std::string_view,Xapian::termcount,Xapian::termpos)\n"
    "    Xapian::Query::Query(std::string_view,Xapian::termcount)\n"
    "    Xapian::Query::Query(std::string_view)\n"
    "    Xapian::Query::Query(Xapian::PostingSource *)\n"
    "    Xapian::Query::Query(double,Xapian::Query const &)\n"
    "    Xapian::Query::Query(Xapian::Query::op,Xapian::Query const &,double)\n"
    "    Xapian::Query::Query(Xapian::Query::op,Xapian::Query const &,Xapian::Query const &)\n"
    "    Xapian::Query::Query(Xapian::Query::op,Xapian::valueno,std::string_view)\n"
    "    Xapian::Query::Query(Xapian::Query::op,Xapian::valueno,std::string_view,std::string_view)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view,Xapian::termcount,int,Xapian::Query::op)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view,Xapian::termcount,int)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view,Xapian::termcount)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view,Xapian::termcount,int,Xapian::Query::op,unsigned int,size_t)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view,Xapian::termcount,int,Xapian::Query::op,unsigned int)\n"
    "    Xapian::Query::Query(Xapian::Query::op,XapianSWIGQueryItor,XapianSWIGQueryItor,Xapian::termcount)\n"
    "    Xapian::Query::Query(Xapian::Query::op,XapianSWIGQueryItor,XapianSWIGQueryItor)\n"
    "    Xapian::Query::Query(Xapian::Query::op)\n"
    "    Xapian::Query::Query(Xapian::Query::op,std::string_view,std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *Query_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Query, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Query_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StemImplementation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::StemImplementation *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::StemImplementation *)new SwigDirector_StemImplementation(arg1); 
        } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
          SWIG_fail;
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__StemImplementation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StemImplementation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::StemImplementation *arg1 = (Xapian::StemImplementation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__StemImplementation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StemImplementation" "', argument " "1"" of type '" "Xapian::StemImplementation *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::StemImplementation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StemImplementation___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::StemImplementation *arg1 = (Xapian::StemImplementation *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "StemImplementation___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__StemImplementation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StemImplementation___call__" "', argument " "1"" of type '" "Xapian::StemImplementation *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::StemImplementation * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StemImplementation___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StemImplementation___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::StemImplementation::operator ()");
        } else {
          result = (arg1)->operator ()((std::string const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StemImplementation_use_proper_noun_heuristic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::StemImplementation *arg1 = (Xapian::StemImplementation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__StemImplementation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StemImplementation_use_proper_noun_heuristic" "', argument " "1"" of type '" "Xapian::StemImplementation const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::StemImplementation * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((Xapian::StemImplementation const *)arg1)->Xapian::StemImplementation::use_proper_noun_heuristic();
        } else {
          result = (bool)((Xapian::StemImplementation const *)arg1)->use_proper_noun_heuristic();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StemImplementation___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::StemImplementation *arg1 = (Xapian::StemImplementation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__StemImplementation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StemImplementation___str__" "', argument " "1"" of type '" "Xapian::StemImplementation const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::StemImplementation * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::StemImplementation::get_description");
        } else {
          result = ((Xapian::StemImplementation const *)arg1)->get_description();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_StemImplementation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::StemImplementation *arg1 = (Xapian::StemImplementation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__StemImplementation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_StemImplementation" "', argument " "1"" of type '" "Xapian::StemImplementation *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::StemImplementation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StemImplementation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__StemImplementation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StemImplementation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Stem__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  bool arg2 ;
  PyObject *bytes1 = NULL ;
  bool val2 ;
  int ecode2 = 0 ;
  Xapian::Stem *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Stem" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Stem *)new Xapian::Stem(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Stem, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Stem__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::Stem *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Stem *)new Xapian::Stem(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Stem, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Stem__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::StemImplementation *arg1 = (Xapian::StemImplementation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::Stem *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__StemImplementation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Stem" "', argument " "1"" of type '" "Xapian::StemImplementation *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::StemImplementation * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Stem *)new Xapian::Stem(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Stem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Stem(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Stem", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Xapian__StemImplementation, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_Stem__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Stem__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Stem__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Stem'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Stem::Stem(std::string_view,bool)\n"
    "    Xapian::Stem::Stem(std::string_view)\n"
    "    Xapian::Stem::Stem(Xapian::StemImplementation *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Stem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Stem" "', argument " "1"" of type '" "Xapian::Stem *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stem * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stem___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Stem___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stem___call__" "', argument " "1"" of type '" "Xapian::Stem const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stem * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stem___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Stem___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Stem const *)arg1)->operator ()((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stem_is_none(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stem_is_none" "', argument " "1"" of type '" "Xapian::Stem const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stem * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::Stem const *)arg1)->is_none();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stem___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stem___str__" "', argument " "1"" of type '" "Xapian::Stem const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stem * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Stem const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stem_get_available_languages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Stem_get_available_languages", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Stem::get_available_languages();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Stem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Stem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Stem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TermGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_TermGenerator", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TermGenerator *)new Xapian::TermGenerator();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TermGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TermGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TermGenerator" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_stemmer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::Stem *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_stemmer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_stemmer" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermGenerator_set_stemmer" "', argument " "2"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TermGenerator_set_stemmer" "', argument " "2"" of type '" "Xapian::Stem const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Stem * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stemmer((Xapian::Stem const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_stopper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::Stopper *arg2 = (Xapian::Stopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_stopper" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermGenerator_set_stopper" "', argument " "2"" of type '" "Xapian::Stopper const *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Stopper * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stopper((Xapian::Stopper const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_stopper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_stopper" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stopper();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_stopper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TermGenerator_set_stopper", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_TermGenerator_set_stopper__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_TermGenerator_set_stopper__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TermGenerator_set_stopper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TermGenerator::set_stopper(Xapian::Stopper const *)\n"
    "    Xapian::TermGenerator::set_stopper()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::Document *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_document", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_document" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermGenerator_set_document" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TermGenerator_set_document" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Document * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_document((Xapian::Document const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_get_document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Document *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_get_document" "', argument " "1"" of type '" "Xapian::TermGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Document *) &((Xapian::TermGenerator const *)arg1)->get_document();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Document, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_database(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::WritableDatabase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_database", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_database" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__WritableDatabase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermGenerator_set_database" "', argument " "2"" of type '" "Xapian::WritableDatabase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TermGenerator_set_database" "', argument " "2"" of type '" "Xapian::WritableDatabase const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::WritableDatabase * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_database((Xapian::WritableDatabase const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_flags__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::TermGenerator::flags arg2 ;
  Xapian::TermGenerator::flags arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::TermGenerator::flags result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_flags" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_flags" "', argument " "2"" of type '" "Xapian::TermGenerator::flags""'");
  } 
  arg2 = static_cast< Xapian::TermGenerator::flags >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TermGenerator_set_flags" "', argument " "3"" of type '" "Xapian::TermGenerator::flags""'");
  } 
  arg3 = static_cast< Xapian::TermGenerator::flags >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TermGenerator::flags)(arg1)->set_flags(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_flags__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::TermGenerator::flags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::TermGenerator::flags result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_flags" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_flags" "', argument " "2"" of type '" "Xapian::TermGenerator::flags""'");
  } 
  arg2 = static_cast< Xapian::TermGenerator::flags >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TermGenerator::flags)(arg1)->set_flags(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_flags(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TermGenerator_set_flags", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_TermGenerator_set_flags__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_TermGenerator_set_flags__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TermGenerator_set_flags'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TermGenerator::set_flags(Xapian::TermGenerator::flags,Xapian::TermGenerator::flags)\n"
    "    Xapian::TermGenerator::set_flags(Xapian::TermGenerator::flags)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_stemming_strategy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::TermGenerator::stem_strategy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_stemming_strategy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_stemming_strategy" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_stemming_strategy" "', argument " "2"" of type '" "Xapian::TermGenerator::stem_strategy""'");
  } 
  arg2 = static_cast< Xapian::TermGenerator::stem_strategy >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stemming_strategy(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_stopper_strategy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::TermGenerator::stop_strategy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_stopper_strategy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_stopper_strategy" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_stopper_strategy" "', argument " "2"" of type '" "Xapian::TermGenerator::stop_strategy""'");
  } 
  arg2 = static_cast< Xapian::TermGenerator::stop_strategy >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stopper_strategy(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_max_word_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_max_word_length", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_max_word_length" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_max_word_length" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_max_word_length(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_index_text" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TermGenerator_index_text" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->index_text(SWIG_STD_MOVE(arg2),arg3,SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_index_text" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TermGenerator_index_text" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->index_text(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_index_text" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->index_text(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TermGenerator_index_text", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_TermGenerator_index_text__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_TermGenerator_index_text__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_TermGenerator_index_text__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TermGenerator_index_text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TermGenerator::index_text(std::string_view,Xapian::termcount,std::string_view)\n"
    "    Xapian::TermGenerator::index_text(std::string_view,Xapian::termcount)\n"
    "    Xapian::TermGenerator::index_text(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text_without_positions__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_index_text_without_positions" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TermGenerator_index_text_without_positions" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->index_text_without_positions(SWIG_STD_MOVE(arg2),arg3,SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text_without_positions__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_index_text_without_positions" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TermGenerator_index_text_without_positions" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->index_text_without_positions(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text_without_positions__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_index_text_without_positions" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->index_text_without_positions(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_index_text_without_positions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TermGenerator_index_text_without_positions", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_TermGenerator_index_text_without_positions__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_TermGenerator_index_text_without_positions__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_TermGenerator_index_text_without_positions__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TermGenerator_index_text_without_positions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TermGenerator::index_text_without_positions(std::string_view,Xapian::termcount,std::string_view)\n"
    "    Xapian::TermGenerator::index_text_without_positions(std::string_view,Xapian::termcount)\n"
    "    Xapian::TermGenerator::index_text_without_positions(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TermGenerator_increase_termpos__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::termpos arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_increase_termpos" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_increase_termpos" "', argument " "2"" of type '" "Xapian::termpos""'");
  } 
  arg2 = static_cast< Xapian::termpos >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->increase_termpos(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_increase_termpos__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_increase_termpos" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->increase_termpos();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_increase_termpos(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TermGenerator_increase_termpos", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_TermGenerator_increase_termpos__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_TermGenerator_increase_termpos__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TermGenerator_increase_termpos'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TermGenerator::increase_termpos(Xapian::termpos)\n"
    "    Xapian::TermGenerator::increase_termpos()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TermGenerator_get_termpos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termpos result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_get_termpos" "', argument " "1"" of type '" "Xapian::TermGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termpos)((Xapian::TermGenerator const *)arg1)->get_termpos();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_termpos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::termpos arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_termpos", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_termpos" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_termpos" "', argument " "2"" of type '" "Xapian::termpos""'");
  } 
  arg2 = static_cast< Xapian::termpos >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_termpos(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator_set_termpos_limit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  Xapian::termpos arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TermGenerator_set_termpos_limit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator_set_termpos_limit" "', argument " "1"" of type '" "Xapian::TermGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TermGenerator_set_termpos_limit" "', argument " "2"" of type '" "Xapian::termpos""'");
  } 
  arg2 = static_cast< Xapian::termpos >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_termpos_limit(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermGenerator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TermGenerator *arg1 = (Xapian::TermGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TermGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermGenerator___str__" "', argument " "1"" of type '" "Xapian::TermGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TermGenerator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::TermGenerator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TermGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__TermGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TermGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_MSet", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::MSet *)new Xapian::MSet();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MSet" "', argument " "1"" of type '" "Xapian::MSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_sort_by_relevance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_sort_by_relevance" "', argument " "1"" of type '" "Xapian::MSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->sort_by_relevance();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_convert_to_percent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_convert_to_percent" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSet_convert_to_percent" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((Xapian::MSet const *)arg1)->convert_to_percent(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_convert_to_percent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_convert_to_percent" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSet_convert_to_percent" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_convert_to_percent" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((Xapian::MSet const *)arg1)->convert_to_percent((Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_convert_to_percent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MSet_convert_to_percent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_MSet_convert_to_percent__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_MSet_convert_to_percent__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MSet_convert_to_percent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::MSet::convert_to_percent(double) const\n"
    "    Xapian::MSet::convert_to_percent(Xapian::MSetIterator const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MSet_get_termfreq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::doccount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MSet_get_termfreq", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_termfreq" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_termfreq(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_termweight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MSet_get_termweight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_termweight" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::MSet const *)arg1)->get_termweight(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_firstitem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_firstitem" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_firstitem();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_matches_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_matches_lower_bound" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_matches_lower_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_matches_estimated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_matches_estimated" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_matches_estimated();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_matches_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_matches_upper_bound" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_matches_upper_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_uncollapsed_matches_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_uncollapsed_matches_lower_bound" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_uncollapsed_matches_lower_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_uncollapsed_matches_estimated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_uncollapsed_matches_estimated" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_uncollapsed_matches_estimated();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_uncollapsed_matches_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_uncollapsed_matches_upper_bound" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_uncollapsed_matches_upper_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_max_attained(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_max_attained" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::MSet const *)arg1)->get_max_attained();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_max_possible(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_max_possible" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::MSet const *)arg1)->get_max_possible();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  size_t arg3 ;
  Xapian::Stem *arg4 = 0 ;
  unsigned int arg5 ;
  std::string_view arg6 ;
  std::string_view arg7 ;
  std::string_view arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *bytes6 = NULL ;
  PyObject *bytes7 = NULL ;
  PyObject *bytes8 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSet_snippet" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  arg4 = reinterpret_cast< Xapian::Stem * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MSet_snippet" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[5]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[5]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[5])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[5], &len, &bytes6);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[5]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[5]);
    }
#endif
    arg6 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[6]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[6]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[6])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[6], &len, &bytes7);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[6]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[6]);
    }
#endif
    arg7 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[7]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[7]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[7])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[7], &len, &bytes8);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[7]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[7]);
    }
#endif
    arg8 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Xapian::Stem const &)*arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  
  SWIG_Py_XDECREF(bytes7);
  
  
  SWIG_Py_XDECREF(bytes8);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  
  SWIG_Py_XDECREF(bytes7);
  
  
  SWIG_Py_XDECREF(bytes8);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  size_t arg3 ;
  Xapian::Stem *arg4 = 0 ;
  unsigned int arg5 ;
  std::string_view arg6 ;
  std::string_view arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *bytes6 = NULL ;
  PyObject *bytes7 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSet_snippet" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  arg4 = reinterpret_cast< Xapian::Stem * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MSet_snippet" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[5]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[5]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[5])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[5], &len, &bytes6);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[5]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[5]);
    }
#endif
    arg6 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[6]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[6]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[6])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[6], &len, &bytes7);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[6]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[6]);
    }
#endif
    arg7 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Xapian::Stem const &)*arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  
  SWIG_Py_XDECREF(bytes7);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  
  SWIG_Py_XDECREF(bytes7);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  size_t arg3 ;
  Xapian::Stem *arg4 = 0 ;
  unsigned int arg5 ;
  std::string_view arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *bytes6 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSet_snippet" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  arg4 = reinterpret_cast< Xapian::Stem * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MSet_snippet" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[5]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[5]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[5])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[5], &len, &bytes6);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[5]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[5]);
    }
#endif
    arg6 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Xapian::Stem const &)*arg4,arg5,SWIG_STD_MOVE(arg6));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes6);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  size_t arg3 ;
  Xapian::Stem *arg4 = 0 ;
  unsigned int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSet_snippet" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  arg4 = reinterpret_cast< Xapian::Stem * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MSet_snippet" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Xapian::Stem const &)*arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  size_t arg3 ;
  Xapian::Stem *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSet_snippet" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_snippet" "', argument " "4"" of type '" "Xapian::Stem const &""'"); 
  }
  arg4 = reinterpret_cast< Xapian::Stem * >(argp4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Xapian::Stem const &)*arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSet_snippet" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_snippet" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->snippet(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_snippet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MSet_snippet", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_MSet_snippet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MSet_snippet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::MSet::snippet(std::string_view,size_t,Xapian::Stem const &,unsigned int,std::string_view,std::string_view,std::string_view) const\n"
    "    Xapian::MSet::snippet(std::string_view,size_t,Xapian::Stem const &,unsigned int,std::string_view,std::string_view) const\n"
    "    Xapian::MSet::snippet(std::string_view,size_t,Xapian::Stem const &,unsigned int,std::string_view) const\n"
    "    Xapian::MSet::snippet(std::string_view,size_t,Xapian::Stem const &,unsigned int) const\n"
    "    Xapian::MSet::snippet(std::string_view,size_t,Xapian::Stem const &) const\n"
    "    Xapian::MSet::snippet(std::string_view,size_t) const\n"
    "    Xapian::MSet::snippet(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MSet_fetch__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  Xapian::MSetIterator *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_fetch" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSet_fetch" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_fetch" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MSet_fetch" "', argument " "3"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_fetch" "', argument " "3"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::MSetIterator * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::MSet const *)arg1)->fetch((Xapian::MSetIterator const &)*arg2,(Xapian::MSetIterator const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_fetch__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_fetch" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSet_fetch" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSet_fetch" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::MSet const *)arg1)->fetch((Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_fetch__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_fetch" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::MSet const *)arg1)->fetch();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_fetch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MSet_fetch", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_MSet_fetch__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_MSet_fetch__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MSet_fetch__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MSet_fetch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::MSet::fetch(Xapian::MSetIterator const &,Xapian::MSetIterator const &) const\n"
    "    Xapian::MSet::fetch(Xapian::MSetIterator const &) const\n"
    "    Xapian::MSet::fetch() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MSet_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_size" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSet const *)arg1)->size();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_empty" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::MSet const *)arg1)->empty();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet__begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MSetIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet__begin" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSetIterator(result)), SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet__end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MSetIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet__end" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->end();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSetIterator(result)), SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MSetIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_back" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->back();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSetIterator(result)), SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet___str__" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSet const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::docid result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MSet_get_docid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_docid" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSet_get_docid" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)Xapian_MSet_get_docid((Xapian::MSet const *)arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::Document result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MSet_get_document", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_document" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSet_get_document" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian_MSet_get_document((Xapian::MSet const *)arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Document(result)), SWIGTYPE_p_Xapian__Document, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet__get_hit_internal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::MSetIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MSet__get_hit_internal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet__get_hit_internal" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSet__get_hit_internal" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian_MSet_get_hit((Xapian::MSet const *)arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSetIterator(result)), SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MSet_get_document_percentage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MSet_get_document_percentage", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSet_get_document_percentage" "', argument " "1"" of type '" "Xapian::MSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSet_get_document_percentage" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)Xapian_MSet_get_document_percentage((Xapian::MSet const *)arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__MSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__MSetIterator_mset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSet *arg2 = (Xapian::MSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_MSetIterator_mset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_mset_set" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MSetIterator_mset_set" "', argument " "2"" of type '" "Xapian::MSet *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSet * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->mset = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_mset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MSet *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_mset_get" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::MSet *)& ((arg1)->mset);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MSet, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_off_from_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSet::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_MSetIterator_off_from_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_off_from_end_set" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MSetIterator_off_from_end_set" "', argument " "2"" of type '" "Xapian::MSet::size_type""'");
  } 
  arg2 = static_cast< Xapian::MSet::size_type >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->off_from_end = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_off_from_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MSet::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_off_from_end_get" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::MSet::size_type) ((arg1)->off_from_end);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__MSetIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__MSetIterator", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::MSetIterator *)new Xapian::MSetIterator();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_rank(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_rank" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSetIterator const *)arg1)->get_rank();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Document result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_document" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSetIterator const *)arg1)->get_document();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Document(result)), SWIGTYPE_p_Xapian__Document, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_weight" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::MSetIterator const *)arg1)->get_weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_collapse_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_collapse_key" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSetIterator const *)arg1)->get_collapse_key();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_collapse_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_collapse_count" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::MSetIterator const *)arg1)->get_collapse_count();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_sort_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_sort_key" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSetIterator const *)arg1)->get_sort_key();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_percent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_percent" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (int)((Xapian::MSetIterator const *)arg1)->get_percent();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator___str__" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::MSetIterator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_MSetIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator___eq__" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MSetIterator___eq__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MSetIterator___eq__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_MSetIterator___eq__(arg1,(Xapian::MSetIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__MSetIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_MSetIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator___ne__" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MSetIterator___ne__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MSetIterator___ne__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_MSetIterator___ne__(arg1,(Xapian::MSetIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__MSetIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_MSetIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_equals" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MSetIterator_equals" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MSetIterator_equals" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_MSetIterator_equals((Xapian::MSetIterator const *)arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_get_docid" "', argument " "1"" of type '" "Xapian::MSetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)Xapian_MSetIterator_get_docid((Xapian::MSetIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator___next__" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_MSetIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MSetIterator_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MSetIterator_prev" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_MSetIterator_prev(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__MSetIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__MSetIterator" "', argument " "1"" of type '" "Xapian::MSetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_MSetIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__MSetIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_MSetIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___eq____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator ==((Xapian::MSetIterator const &)*arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::MSetIterator const &)*arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator <((Xapian::MSetIterator const &)*arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__gt__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator >((Xapian::MSetIterator const &)*arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ge__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator >=((Xapian::MSetIterator const &)*arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MSetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__le__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator <=((Xapian::MSetIterator const &)*arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___add____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MSetIterator::difference_type arg1 ;
  Xapian::MSetIterator *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::MSetIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__add__" "', argument " "1"" of type '" "Xapian::MSetIterator::difference_type""'");
  } 
  arg1 = static_cast< Xapian::MSetIterator::difference_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__add__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__add__" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::operator +(arg1,(Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSetIterator(result)), SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_ESet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ESet", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ESet *)new Xapian::ESet();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ESet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ESet" "', argument " "1"" of type '" "Xapian::ESet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet_size" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::ESet const *)arg1)->size();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet_empty" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::ESet const *)arg1)->empty();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet_get_ebound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet_get_ebound" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::ESet const *)arg1)->get_ebound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet__begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ESetIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet__begin" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ESet const *)arg1)->begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESetIterator(result)), SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet__end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ESetIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet__end" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ESet const *)arg1)->end();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESetIterator(result)), SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ESetIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet_back" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ESet const *)arg1)->back();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESetIterator(result)), SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ESet___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESet___str__" "', argument " "1"" of type '" "Xapian::ESet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ESet const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ESet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ESet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ESet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__ESetIterator_eset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESet *arg2 = (Xapian::ESet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ESetIterator_eset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_eset_set" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ESetIterator_eset_set" "', argument " "2"" of type '" "Xapian::ESet *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESet * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->eset = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator_eset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ESet *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_eset_get" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::ESet *)& ((arg1)->eset);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ESet, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator_off_from_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESet::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ESetIterator_off_from_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_off_from_end_set" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ESetIterator_off_from_end_set" "', argument " "2"" of type '" "Xapian::ESet::size_type""'");
  } 
  arg2 = static_cast< Xapian::ESet::size_type >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->off_from_end = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator_off_from_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ESet::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_off_from_end_get" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::ESet::size_type) ((arg1)->off_from_end);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__ESetIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new__ESetIterator", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ESetIterator *)new Xapian::ESetIterator();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator_get_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_get_weight" "', argument " "1"" of type '" "Xapian::ESetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::ESetIterator const *)arg1)->get_weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator___str__" "', argument " "1"" of type '" "Xapian::ESetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ESetIterator const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ESetIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator___eq__" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ESetIterator___eq__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ESetIterator___eq__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_ESetIterator___eq__(arg1,(Xapian::ESetIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__ESetIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ESetIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator___ne__" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ESetIterator___ne__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ESetIterator___ne__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)Xapian_ESetIterator___ne__(arg1,(Xapian::ESetIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap__ESetIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "_ESetIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_equals" "', argument " "1"" of type '" "Xapian::ESetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_ESetIterator_equals" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_ESetIterator_equals" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_ESetIterator_equals((Xapian::ESetIterator const *)arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator_get_term(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_get_term" "', argument " "1"" of type '" "Xapian::ESetIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian_ESetIterator_get_term((Xapian::ESetIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator___next__" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_ESetIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__ESetIterator_prev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_ESetIterator_prev" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_ESetIterator_prev(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__ESetIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__ESetIterator" "', argument " "1"" of type '" "Xapian::ESetIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_ESetIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ESetIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_ESetIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___eq____SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator ==((Xapian::ESetIterator const &)*arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___eq____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap___eq____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap___eq____SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap___eq____SWIG_3(self, argc, argv);
  }
check_4:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap___eq____SWIG_4(self, argc, argv);
  }
check_5:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___eq____SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::ESetIterator const &)*arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator <((Xapian::ESetIterator const &)*arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lt__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__lt__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___lt____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___lt____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__gt__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator >((Xapian::ESetIterator const &)*arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___gt__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__gt__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___gt____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___gt____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ge__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator >=((Xapian::ESetIterator const &)*arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__ge__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___ge____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___ge____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ESetIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__le__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator <=((Xapian::ESetIterator const &)*arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___le__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__le__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___le____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___le____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___add____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::ESetIterator::difference_type arg1 ;
  Xapian::ESetIterator *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::ESetIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__add__" "', argument " "1"" of type '" "Xapian::ESetIterator::difference_type""'");
  } 
  arg1 = static_cast< Xapian::ESetIterator::difference_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ESetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__add__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__add__" "', argument " "2"" of type '" "Xapian::ESetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ESetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::operator +(arg1,(Xapian::ESetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESetIterator(result)), SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___add__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__add__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___add____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___add____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_RSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RSet *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_RSet", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::RSet *)new Xapian::RSet();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RSet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RSet" "', argument " "1"" of type '" "Xapian::RSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_size" "', argument " "1"" of type '" "Xapian::RSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::RSet const *)arg1)->size();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_empty" "', argument " "1"" of type '" "Xapian::RSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::RSet const *)arg1)->empty();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_add_document__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_add_document" "', argument " "1"" of type '" "Xapian::RSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RSet_add_document" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_document(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_add_document__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_add_document" "', argument " "1"" of type '" "Xapian::RSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RSet_add_document" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RSet_add_document" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_document((Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_add_document(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RSet_add_document", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_RSet_add_document__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_RSet_add_document__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RSet_add_document'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::RSet::add_document(Xapian::docid)\n"
    "    Xapian::RSet::add_document(Xapian::MSetIterator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RSet_remove_document__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_remove_document" "', argument " "1"" of type '" "Xapian::RSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RSet_remove_document" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_document(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_remove_document__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_remove_document" "', argument " "1"" of type '" "Xapian::RSet *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RSet_remove_document" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RSet_remove_document" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_document((Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_remove_document(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RSet_remove_document", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_RSet_remove_document__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_RSet_remove_document__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RSet_remove_document'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::RSet::remove_document(Xapian::docid)\n"
    "    Xapian::RSet::remove_document(Xapian::MSetIterator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RSet_contains__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_contains" "', argument " "1"" of type '" "Xapian::RSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RSet_contains" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::RSet const *)arg1)->contains(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_contains__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet_contains" "', argument " "1"" of type '" "Xapian::RSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RSet_contains" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RSet_contains" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::RSet const *)arg1)->contains((Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RSet_contains(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RSet_contains", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_RSet_contains__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_RSet_contains__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RSet_contains'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::RSet::contains(Xapian::docid) const\n"
    "    Xapian::RSet::contains(Xapian::MSetIterator const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RSet___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RSet___str__" "', argument " "1"" of type '" "Xapian::RSet const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RSet * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::RSet const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__RSet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MatchDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MatchDecider *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if ( arg1 != Py_None ) {
      /* subclassed */
      result = (Xapian::MatchDecider *)new SwigDirector_MatchDecider(arg1); 
    } else {
      SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
      SWIG_fail;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MatchDecider, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MatchDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchDecider *arg1 = (Xapian::MatchDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchDecider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatchDecider" "', argument " "1"" of type '" "Xapian::MatchDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchDecider * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatchDecider___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchDecider *arg1 = (Xapian::MatchDecider *) 0 ;
  Xapian::Document *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MatchDecider___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatchDecider___call__" "', argument " "1"" of type '" "Xapian::MatchDecider const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchDecider * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatchDecider___call__" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatchDecider___call__" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Document * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::MatchDecider::operator ()");
        } else {
          result = (bool)((Xapian::MatchDecider const *)arg1)->operator ()((Xapian::Document const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_MatchDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchDecider *arg1 = (Xapian::MatchDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MatchDecider" "', argument " "1"" of type '" "Xapian::MatchDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchDecider * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatchDecider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__MatchDecider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MatchDecider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Enquire(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Enquire *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Enquire" "', argument " "1"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Enquire" "', argument " "1"" of type '" "Xapian::Database const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Enquire *)new Xapian::Enquire((Xapian::Database const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Enquire, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Enquire(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Enquire" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_query__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Query *arg2 = 0 ;
  Xapian::termcount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_query" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Query,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_set_query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_set_query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Query * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_query" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_query((Xapian::Query const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_query__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Query *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_query" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Query,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_set_query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_set_query" "', argument " "2"" of type '" "Xapian::Query const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Query * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_query((Xapian::Query const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_query(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire_set_query", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Enquire_set_query__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Enquire_set_query__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire_set_query'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::set_query(Xapian::Query const &,Xapian::termcount)\n"
    "    Xapian::Enquire::set_query(Xapian::Query const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire_get_query(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Query *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_query" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query *) &((Xapian::Enquire const *)arg1)->get_query();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Query, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_weighting_scheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Weight *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_weighting_scheme", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_weighting_scheme" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Weight,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_set_weighting_scheme" "', argument " "2"" of type '" "Xapian::Weight const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_set_weighting_scheme" "', argument " "2"" of type '" "Xapian::Weight const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Weight * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_weighting_scheme((Xapian::Weight const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_docid_order(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Enquire::docid_order arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_docid_order", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_docid_order" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_docid_order" "', argument " "2"" of type '" "Xapian::Enquire::docid_order""'");
  } 
  arg2 = static_cast< Xapian::Enquire::docid_order >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_docid_order(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_relevance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_relevance" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_relevance();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_sort_by_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_value" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_sort_by_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_sort_by_value" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_value(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::KeyMaker *arg2 = (Xapian::KeyMaker *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_sort_by_key", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_key" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_set_sort_by_key" "', argument " "2"" of type '" "Xapian::KeyMaker *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::KeyMaker * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_sort_by_key" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_key(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_value_then_relevance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_sort_by_value_then_relevance", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_value_then_relevance" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_sort_by_value_then_relevance" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_sort_by_value_then_relevance" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_value_then_relevance(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_key_then_relevance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::KeyMaker *arg2 = (Xapian::KeyMaker *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_sort_by_key_then_relevance", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_key_then_relevance" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_set_sort_by_key_then_relevance" "', argument " "2"" of type '" "Xapian::KeyMaker *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::KeyMaker * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_sort_by_key_then_relevance" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_key_then_relevance(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_relevance_then_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_sort_by_relevance_then_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_relevance_then_value" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_sort_by_relevance_then_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_sort_by_relevance_then_value" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_relevance_then_value(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_sort_by_relevance_then_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::KeyMaker *arg2 = (Xapian::KeyMaker *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_sort_by_relevance_then_key", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_sort_by_relevance_then_key" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_set_sort_by_relevance_then_key" "', argument " "2"" of type '" "Xapian::KeyMaker *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::KeyMaker * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_sort_by_relevance_then_key" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_sort_by_relevance_then_key(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_collapse_key__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  Xapian::doccount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_collapse_key" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_collapse_key" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_collapse_key" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_collapse_key(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_collapse_key__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_collapse_key" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_collapse_key" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_collapse_key(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_collapse_key(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire_set_collapse_key", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Enquire_set_collapse_key__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Enquire_set_collapse_key__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire_set_collapse_key'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::set_collapse_key(Xapian::valueno,Xapian::doccount)\n"
    "    Xapian::Enquire::set_collapse_key(Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire_set_cutoff__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_cutoff" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_cutoff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_cutoff" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_cutoff(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_cutoff__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_cutoff" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_cutoff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_cutoff(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_cutoff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire_set_cutoff", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Enquire_set_cutoff__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Enquire_set_cutoff__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire_set_cutoff'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::set_cutoff(int,double)\n"
    "    Xapian::Enquire::set_cutoff(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire_add_matchspy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::MatchSpy *arg2 = (Xapian::MatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_add_matchspy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_add_matchspy" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire_add_matchspy" "', argument " "2"" of type '" "Xapian::MatchSpy *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MatchSpy * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_matchspy(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_clear_matchspies(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_clear_matchspies" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->clear_matchspies();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_time_limit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Enquire_set_time_limit", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_time_limit" "', argument " "1"" of type '" "Xapian::Enquire *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_set_time_limit" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_time_limit(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::doccount arg4 ;
  Xapian::RSet *arg5 = (Xapian::RSet *) 0 ;
  Xapian::MatchDecider *arg6 = (Xapian::MatchDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Xapian::MSet result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_mset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_mset" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_get_mset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Enquire_get_mset" "', argument " "4"" of type '" "Xapian::doccount""'");
  } 
  arg4 = static_cast< Xapian::doccount >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Enquire_get_mset" "', argument " "5"" of type '" "Xapian::RSet const *""'"); 
  }
  arg5 = reinterpret_cast< Xapian::RSet * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_Xapian__MatchDecider, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Enquire_get_mset" "', argument " "6"" of type '" "Xapian::MatchDecider const *""'"); 
  }
  arg6 = reinterpret_cast< Xapian::MatchDecider * >(argp6);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,arg4,(Xapian::RSet const *)arg5,(Xapian::MatchDecider const *)arg6);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSet(result)), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::doccount arg4 ;
  Xapian::RSet *arg5 = (Xapian::RSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Xapian::MSet result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_mset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_mset" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_get_mset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Enquire_get_mset" "', argument " "4"" of type '" "Xapian::doccount""'");
  } 
  arg4 = static_cast< Xapian::doccount >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Enquire_get_mset" "', argument " "5"" of type '" "Xapian::RSet const *""'"); 
  }
  arg5 = reinterpret_cast< Xapian::RSet * >(argp5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,arg4,(Xapian::RSet const *)arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSet(result)), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::doccount arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Xapian::MSet result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_mset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_mset" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_get_mset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Enquire_get_mset" "', argument " "4"" of type '" "Xapian::doccount""'");
  } 
  arg4 = static_cast< Xapian::doccount >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSet(result)), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::MSet result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_mset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_mset" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_get_mset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSet(result)), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::RSet *arg4 = (Xapian::RSet *) 0 ;
  Xapian::MatchDecider *arg5 = (Xapian::MatchDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Xapian::MSet result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_mset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_mset" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_get_mset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Enquire_get_mset" "', argument " "4"" of type '" "Xapian::RSet const *""'"); 
  }
  arg4 = reinterpret_cast< Xapian::RSet * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Xapian__MatchDecider, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Enquire_get_mset" "', argument " "5"" of type '" "Xapian::MatchDecider const *""'"); 
  }
  arg5 = reinterpret_cast< Xapian::MatchDecider * >(argp5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,(Xapian::RSet const *)arg4,(Xapian::MatchDecider const *)arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSet(result)), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::RSet *arg4 = (Xapian::RSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Xapian::MSet result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_mset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_mset" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_get_mset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Xapian__RSet, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Enquire_get_mset" "', argument " "4"" of type '" "Xapian::RSet const *""'"); 
  }
  arg4 = reinterpret_cast< Xapian::RSet * >(argp4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,(Xapian::RSet const *)arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::MSet(result)), SWIGTYPE_p_Xapian__MSet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_mset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire_get_mset", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Enquire_get_mset__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Xapian__RSet, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Enquire_get_mset__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Enquire_get_mset__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Xapian__RSet, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Xapian__MatchDecider, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_Enquire_get_mset__SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_Enquire_get_mset__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_Enquire_get_mset__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire_get_mset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::get_mset(Xapian::doccount,Xapian::doccount,Xapian::doccount,Xapian::RSet const *,Xapian::MatchDecider const *) const\n"
    "    Xapian::Enquire::get_mset(Xapian::doccount,Xapian::doccount,Xapian::doccount,Xapian::RSet const *) const\n"
    "    Xapian::Enquire::get_mset(Xapian::doccount,Xapian::doccount,Xapian::doccount) const\n"
    "    Xapian::Enquire::get_mset(Xapian::doccount,Xapian::doccount) const\n"
    "    Xapian::Enquire::get_mset(Xapian::doccount,Xapian::doccount,Xapian::RSet const *,Xapian::MatchDecider const *) const\n"
    "    Xapian::Enquire::get_mset(Xapian::doccount,Xapian::doccount,Xapian::RSet const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire__get_matching_terms_begin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire__get_matching_terms_begin" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire__get_matching_terms_begin" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_matching_terms_begin(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire__get_matching_terms_begin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire__get_matching_terms_begin" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire__get_matching_terms_begin" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire__get_matching_terms_begin" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_matching_terms_begin((Xapian::MSetIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire__get_matching_terms_begin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire__get_matching_terms_begin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Enquire__get_matching_terms_begin__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Enquire__get_matching_terms_begin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire__get_matching_terms_begin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::get_matching_terms_begin(Xapian::docid) const\n"
    "    Xapian::Enquire::get_matching_terms_begin(Xapian::MSetIterator const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire__get_matching_terms_end__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire__get_matching_terms_end" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire__get_matching_terms_end" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Enquire const *)arg1)->get_matching_terms_end(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire__get_matching_terms_end__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire__get_matching_terms_end" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__MSetIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Enquire__get_matching_terms_end" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire__get_matching_terms_end" "', argument " "2"" of type '" "Xapian::MSetIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::MSetIterator * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Enquire const *)arg1)->get_matching_terms_end((Xapian::MSetIterator const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire__get_matching_terms_end(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire__get_matching_terms_end", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_Enquire__get_matching_terms_end__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Enquire__get_matching_terms_end__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire__get_matching_terms_end'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::get_matching_terms_end(Xapian::docid) const\n"
    "    Xapian::Enquire::get_matching_terms_end(Xapian::MSetIterator const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire_set_expansion_scheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  std::string_view arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_expansion_scheme" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Enquire_set_expansion_scheme" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::Enquire const *)arg1)->set_expansion_scheme(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_expansion_scheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_set_expansion_scheme" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::Enquire const *)arg1)->set_expansion_scheme(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_set_expansion_scheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire_set_expansion_scheme", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Enquire_set_expansion_scheme__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Enquire_set_expansion_scheme__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire_set_expansion_scheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::set_expansion_scheme(std::string_view,double) const\n"
    "    Xapian::Enquire::set_expansion_scheme(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire_get_eset__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  int arg4 ;
  Xapian::ExpandDecider *arg5 = (Xapian::ExpandDecider *) 0 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Xapian::ESet result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_eset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_eset" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__RSet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::RSet * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Enquire_get_eset" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Enquire_get_eset" "', argument " "5"" of type '" "Xapian::ExpandDecider const *""'"); 
  }
  arg5 = reinterpret_cast< Xapian::ExpandDecider * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Enquire_get_eset" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,arg4,(Xapian::ExpandDecider const *)arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESet(result)), SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_eset__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  int arg4 ;
  Xapian::ExpandDecider *arg5 = (Xapian::ExpandDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Xapian::ESet result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_eset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_eset" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__RSet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::RSet * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Enquire_get_eset" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Enquire_get_eset" "', argument " "5"" of type '" "Xapian::ExpandDecider const *""'"); 
  }
  arg5 = reinterpret_cast< Xapian::ExpandDecider * >(argp5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,arg4,(Xapian::ExpandDecider const *)arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESet(result)), SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_eset__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Xapian::ESet result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_eset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_eset" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__RSet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::RSet * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Enquire_get_eset" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESet(result)), SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_eset__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Xapian::ESet result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_eset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_eset" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__RSet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::RSet * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESet(result)), SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_eset__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  Xapian::ExpandDecider *arg4 = (Xapian::ExpandDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Xapian::ESet result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire_get_eset" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Enquire_get_eset" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__RSet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Enquire_get_eset" "', argument " "3"" of type '" "Xapian::RSet const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::RSet * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Enquire_get_eset" "', argument " "4"" of type '" "Xapian::ExpandDecider const *""'"); 
  }
  arg4 = reinterpret_cast< Xapian::ExpandDecider * >(argp4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,(Xapian::ExpandDecider const *)arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ESet(result)), SWIGTYPE_p_Xapian__ESet, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Enquire_get_eset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Enquire_get_eset", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_Enquire_get_eset__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Xapian__ExpandDecider, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_Enquire_get_eset__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Enquire_get_eset__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Enquire_get_eset__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_Enquire_get_eset__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Enquire_get_eset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Enquire::get_eset(Xapian::termcount,Xapian::RSet const &,int,Xapian::ExpandDecider const *,double) const\n"
    "    Xapian::Enquire::get_eset(Xapian::termcount,Xapian::RSet const &,int,Xapian::ExpandDecider const *) const\n"
    "    Xapian::Enquire::get_eset(Xapian::termcount,Xapian::RSet const &,int) const\n"
    "    Xapian::Enquire::get_eset(Xapian::termcount,Xapian::RSet const &) const\n"
    "    Xapian::Enquire::get_eset(Xapian::termcount,Xapian::RSet const &,Xapian::ExpandDecider const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Enquire___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Enquire, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enquire___str__" "', argument " "1"" of type '" "Xapian::Enquire const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Enquire * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Enquire const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Enquire_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Enquire, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Enquire_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExpandDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ExpandDecider *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::ExpandDecider *)new SwigDirector_ExpandDecider(arg1); 
        } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
          SWIG_fail;
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ExpandDecider, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExpandDecider___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDecider *arg1 = (Xapian::ExpandDecider *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ExpandDecider___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpandDecider___call__" "', argument " "1"" of type '" "Xapian::ExpandDecider const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDecider * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExpandDecider___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpandDecider___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::ExpandDecider::operator ()");
        } else {
          result = (bool)((Xapian::ExpandDecider const *)arg1)->operator ()((std::string const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExpandDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDecider *arg1 = (Xapian::ExpandDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ExpandDecider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpandDecider" "', argument " "1"" of type '" "Xapian::ExpandDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDecider * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExpandDecider_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDecider *arg1 = (Xapian::ExpandDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::ExpandDecider *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpandDecider_release" "', argument " "1"" of type '" "Xapian::ExpandDecider const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDecider * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ExpandDecider *)((Xapian::ExpandDecider const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_ExpandDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDecider *arg1 = (Xapian::ExpandDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ExpandDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ExpandDecider" "', argument " "1"" of type '" "Xapian::ExpandDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDecider * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpandDecider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ExpandDecider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExpandDecider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExpandDeciderAnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDecider *arg1 = 0 ;
  Xapian::ExpandDecider *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::ExpandDeciderAnd *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ExpandDeciderAnd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__ExpandDecider,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpandDeciderAnd" "', argument " "1"" of type '" "Xapian::ExpandDecider const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpandDeciderAnd" "', argument " "1"" of type '" "Xapian::ExpandDecider const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDecider * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__ExpandDecider,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExpandDeciderAnd" "', argument " "2"" of type '" "Xapian::ExpandDecider const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpandDeciderAnd" "', argument " "2"" of type '" "Xapian::ExpandDecider const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::ExpandDecider * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ExpandDeciderAnd *)new Xapian::ExpandDeciderAnd((Xapian::ExpandDecider const &)*arg1,(Xapian::ExpandDecider const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ExpandDeciderAnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExpandDeciderAnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDeciderAnd *arg1 = (Xapian::ExpandDeciderAnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ExpandDeciderAnd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpandDeciderAnd" "', argument " "1"" of type '" "Xapian::ExpandDeciderAnd *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDeciderAnd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpandDeciderAnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ExpandDeciderAnd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExpandDeciderAnd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExpandDeciderFilterPrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  Xapian::ExpandDeciderFilterPrefix *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = XapianSWIG_anystring_as_ptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      if (res1 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpandDeciderFilterPrefix" "', argument " "1"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpandDeciderFilterPrefix" "', argument " "1"" of type '" "std::string const &""'");
    }
    arg1 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ExpandDeciderFilterPrefix *)new Xapian::ExpandDeciderFilterPrefix((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ExpandDeciderFilterPrefix, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExpandDeciderFilterPrefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ExpandDeciderFilterPrefix *arg1 = (Xapian::ExpandDeciderFilterPrefix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ExpandDeciderFilterPrefix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpandDeciderFilterPrefix" "', argument " "1"" of type '" "Xapian::ExpandDeciderFilterPrefix *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ExpandDeciderFilterPrefix * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpandDeciderFilterPrefix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ExpandDeciderFilterPrefix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExpandDeciderFilterPrefix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KeyMaker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::KeyMaker *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::KeyMaker *)new SwigDirector_KeyMaker(arg1); 
        } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
          SWIG_fail;
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__KeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KeyMaker___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::KeyMaker *arg1 = (Xapian::KeyMaker *) 0 ;
  Xapian::Document *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "KeyMaker___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyMaker___call__" "', argument " "1"" of type '" "Xapian::KeyMaker const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::KeyMaker * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeyMaker___call__" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeyMaker___call__" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Document * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::KeyMaker::operator ()");
        } else {
          result = ((Xapian::KeyMaker const *)arg1)->operator ()((Xapian::Document const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KeyMaker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::KeyMaker *arg1 = (Xapian::KeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__KeyMaker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyMaker" "', argument " "1"" of type '" "Xapian::KeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::KeyMaker * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KeyMaker_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::KeyMaker *arg1 = (Xapian::KeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyMaker_name" "', argument " "1"" of type '" "Xapian::KeyMaker const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::KeyMaker * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::KeyMaker const *)arg1)->Xapian::KeyMaker::name();
        } else {
          result = ((Xapian::KeyMaker const *)arg1)->name();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KeyMaker_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::KeyMaker *arg1 = (Xapian::KeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::KeyMaker *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyMaker_release" "', argument " "1"" of type '" "Xapian::KeyMaker const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::KeyMaker * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::KeyMaker *)((Xapian::KeyMaker const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_KeyMaker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::KeyMaker *arg1 = (Xapian::KeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__KeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_KeyMaker" "', argument " "1"" of type '" "Xapian::KeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::KeyMaker * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KeyMaker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__KeyMaker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KeyMaker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MultiValueKeyMaker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MultiValueKeyMaker *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_MultiValueKeyMaker", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::MultiValueKeyMaker *)new Xapian::MultiValueKeyMaker();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MultiValueKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiValueKeyMaker_add_value__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MultiValueKeyMaker *arg1 = (Xapian::MultiValueKeyMaker *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MultiValueKeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiValueKeyMaker_add_value" "', argument " "1"" of type '" "Xapian::MultiValueKeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MultiValueKeyMaker * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiValueKeyMaker_add_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultiValueKeyMaker_add_value" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_value(arg2,arg3,SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiValueKeyMaker_add_value__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MultiValueKeyMaker *arg1 = (Xapian::MultiValueKeyMaker *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MultiValueKeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiValueKeyMaker_add_value" "', argument " "1"" of type '" "Xapian::MultiValueKeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MultiValueKeyMaker * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiValueKeyMaker_add_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultiValueKeyMaker_add_value" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_value(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiValueKeyMaker_add_value__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::MultiValueKeyMaker *arg1 = (Xapian::MultiValueKeyMaker *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MultiValueKeyMaker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiValueKeyMaker_add_value" "', argument " "1"" of type '" "Xapian::MultiValueKeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MultiValueKeyMaker * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiValueKeyMaker_add_value" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_value(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiValueKeyMaker_add_value(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultiValueKeyMaker_add_value", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_MultiValueKeyMaker_add_value__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_MultiValueKeyMaker_add_value__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_MultiValueKeyMaker_add_value__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultiValueKeyMaker_add_value'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::MultiValueKeyMaker::add_value(Xapian::valueno,bool,std::string_view)\n"
    "    Xapian::MultiValueKeyMaker::add_value(Xapian::valueno,bool)\n"
    "    Xapian::MultiValueKeyMaker::add_value(Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultiValueKeyMaker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MultiValueKeyMaker *arg1 = (Xapian::MultiValueKeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MultiValueKeyMaker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiValueKeyMaker" "', argument " "1"" of type '" "Xapian::MultiValueKeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MultiValueKeyMaker * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultiValueKeyMaker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__MultiValueKeyMaker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MultiValueKeyMaker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Stopper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Stopper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::Stopper *)new SwigDirector_Stopper(arg1); 
        } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
          SWIG_fail;
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Stopper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stopper___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Stopper___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stopper___call__" "', argument " "1"" of type '" "Xapian::Stopper const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stopper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stopper___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Stopper___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::Stopper::operator ()");
        } else {
          result = (bool)((Xapian::Stopper const *)arg1)->operator ()((std::string const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Stopper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stopper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Stopper" "', argument " "1"" of type '" "Xapian::Stopper *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stopper * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stopper___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stopper___str__" "', argument " "1"" of type '" "Xapian::Stopper const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stopper * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::Stopper const *)arg1)->Xapian::Stopper::get_description();
        } else {
          result = ((Xapian::Stopper const *)arg1)->get_description();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Stopper_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::Stopper *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stopper_release" "', argument " "1"" of type '" "Xapian::Stopper const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stopper * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Stopper *)((Xapian::Stopper const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Stopper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Stopper" "', argument " "1"" of type '" "Xapian::Stopper *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Stopper * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Stopper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Stopper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Stopper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SimpleStopper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::SimpleStopper *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::SimpleStopper *)new Xapian::SimpleStopper();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SimpleStopper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleStopper_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::SimpleStopper *arg1 = (Xapian::SimpleStopper *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SimpleStopper_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__SimpleStopper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleStopper_add" "', argument " "1"" of type '" "Xapian::SimpleStopper *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::SimpleStopper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleStopper_add" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleStopper_add" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimpleStopper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Xapian::SimpleStopper *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = XapianSWIG_anystring_as_ptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      if (res1 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SimpleStopper" "', argument " "1"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SimpleStopper" "', argument " "1"" of type '" "std::string const &""'");
    }
    arg1 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::SimpleStopper *)new_Xapian_SimpleStopper__SWIG_1((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__SimpleStopper, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimpleStopper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SimpleStopper", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_SimpleStopper__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_SimpleStopper__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SimpleStopper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::SimpleStopper::SimpleStopper()\n"
    "    Xapian::SimpleStopper::SimpleStopper(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SimpleStopper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::SimpleStopper *arg1 = (Xapian::SimpleStopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__SimpleStopper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleStopper" "', argument " "1"" of type '" "Xapian::SimpleStopper *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::SimpleStopper * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SimpleStopper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__SimpleStopper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SimpleStopper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RangeProcessor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Xapian::RangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::RangeProcessor *)new SwigDirector_RangeProcessor(arg1); 
        } else {
          result = (Xapian::RangeProcessor *)new Xapian::RangeProcessor(); 
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeProcessor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Xapian::valueno arg2 ;
  std::string_view arg3 ;
  unsigned int arg4 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Xapian::RangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RangeProcessor" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RangeProcessor" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::RangeProcessor *)new SwigDirector_RangeProcessor(arg1,arg2,SWIG_STD_MOVE(arg3),arg4); 
        } else {
          result = (Xapian::RangeProcessor *)new Xapian::RangeProcessor(arg2,SWIG_STD_MOVE(arg3),arg4); 
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeProcessor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Xapian::valueno arg2 ;
  std::string_view arg3 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  Xapian::RangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RangeProcessor" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::RangeProcessor *)new SwigDirector_RangeProcessor(arg1,arg2,SWIG_STD_MOVE(arg3)); 
        } else {
          result = (Xapian::RangeProcessor *)new Xapian::RangeProcessor(arg2,SWIG_STD_MOVE(arg3)); 
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeProcessor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Xapian::valueno arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::RangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RangeProcessor" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::RangeProcessor *)new SwigDirector_RangeProcessor(arg1,arg2); 
        } else {
          result = (Xapian::RangeProcessor *)new Xapian::RangeProcessor(arg2); 
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RangeProcessor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RangeProcessor", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_RangeProcessor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_RangeProcessor__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_RangeProcessor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_RangeProcessor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RangeProcessor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::RangeProcessor::RangeProcessor()\n"
    "    Xapian::RangeProcessor::RangeProcessor(Xapian::valueno,std::string_view,unsigned int)\n"
    "    Xapian::RangeProcessor::RangeProcessor(Xapian::valueno,std::string_view)\n"
    "    Xapian::RangeProcessor::RangeProcessor(PyObject *,Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RangeProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RangeProcessor *arg1 = (Xapian::RangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RangeProcessor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RangeProcessor" "', argument " "1"" of type '" "Xapian::RangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RangeProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeProcessor_check_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RangeProcessor *arg1 = (Xapian::RangeProcessor *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Xapian::Query result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RangeProcessor_check_range", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeProcessor_check_range" "', argument " "1"" of type '" "Xapian::RangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RangeProcessor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RangeProcessor_check_range" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RangeProcessor_check_range" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = XapianSWIG_anystring_as_ptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      if (res3 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RangeProcessor_check_range" "', argument " "3"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RangeProcessor_check_range" "', argument " "3"" of type '" "std::string const &""'");
    }
    arg3 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->check_range((std::string const &)*arg2,(std::string const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeProcessor___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RangeProcessor *arg1 = (Xapian::RangeProcessor *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::Query result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "RangeProcessor___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeProcessor___call__" "', argument " "1"" of type '" "Xapian::RangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RangeProcessor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RangeProcessor___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RangeProcessor___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = XapianSWIG_anystring_as_ptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      if (res3 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RangeProcessor___call__" "', argument " "3"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RangeProcessor___call__" "', argument " "3"" of type '" "std::string const &""'");
    }
    arg3 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->Xapian::RangeProcessor::operator ()((std::string const &)*arg2,(std::string const &)*arg3);
        } else {
          result = (arg1)->operator ()((std::string const &)*arg2,(std::string const &)*arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RangeProcessor_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RangeProcessor *arg1 = (Xapian::RangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::RangeProcessor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangeProcessor_release" "', argument " "1"" of type '" "Xapian::RangeProcessor const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RangeProcessor * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::RangeProcessor *)((Xapian::RangeProcessor const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_RangeProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::RangeProcessor *arg1 = (Xapian::RangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_RangeProcessor" "', argument " "1"" of type '" "Xapian::RangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::RangeProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RangeProcessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__RangeProcessor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RangeProcessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DateRangeProcessor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int arg2 ;
  int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::DateRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateRangeProcessor" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateRangeProcessor" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DateRangeProcessor *)new Xapian::DateRangeProcessor(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateRangeProcessor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::DateRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateRangeProcessor" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DateRangeProcessor *)new Xapian::DateRangeProcessor(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateRangeProcessor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Xapian::DateRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DateRangeProcessor *)new Xapian::DateRangeProcessor(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateRangeProcessor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Xapian::DateRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateRangeProcessor" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateRangeProcessor" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DateRangeProcessor *)new Xapian::DateRangeProcessor(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateRangeProcessor__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::DateRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateRangeProcessor" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DateRangeProcessor *)new Xapian::DateRangeProcessor(arg1,SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateRangeProcessor__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  std::string_view arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::DateRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DateRangeProcessor *)new Xapian::DateRangeProcessor(arg1,SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateRangeProcessor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DateRangeProcessor", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DateRangeProcessor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_DateRangeProcessor__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DateRangeProcessor__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_DateRangeProcessor__SWIG_0(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DateRangeProcessor__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_DateRangeProcessor__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DateRangeProcessor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno,unsigned int,int)\n"
    "    Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno,unsigned int)\n"
    "    Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno)\n"
    "    Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno,std::string_view,unsigned int,int)\n"
    "    Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno,std::string_view,unsigned int)\n"
    "    Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno,std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DateRangeProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DateRangeProcessor *arg1 = (Xapian::DateRangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateRangeProcessor" "', argument " "1"" of type '" "Xapian::DateRangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DateRangeProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DateRangeProcessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DateRangeProcessor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DateRangeProcessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NumberRangeProcessor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::NumberRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NumberRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NumberRangeProcessor" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::NumberRangeProcessor *)new Xapian::NumberRangeProcessor(arg1,SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NumberRangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberRangeProcessor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  std::string_view arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::NumberRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NumberRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::NumberRangeProcessor *)new Xapian::NumberRangeProcessor(arg1,SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NumberRangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberRangeProcessor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Xapian::NumberRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NumberRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::NumberRangeProcessor *)new Xapian::NumberRangeProcessor(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__NumberRangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberRangeProcessor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NumberRangeProcessor", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_NumberRangeProcessor__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_NumberRangeProcessor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_NumberRangeProcessor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NumberRangeProcessor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::NumberRangeProcessor::NumberRangeProcessor(Xapian::valueno,std::string_view,unsigned int)\n"
    "    Xapian::NumberRangeProcessor::NumberRangeProcessor(Xapian::valueno,std::string_view)\n"
    "    Xapian::NumberRangeProcessor::NumberRangeProcessor(Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NumberRangeProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::NumberRangeProcessor *arg1 = (Xapian::NumberRangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__NumberRangeProcessor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NumberRangeProcessor" "', argument " "1"" of type '" "Xapian::NumberRangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::NumberRangeProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NumberRangeProcessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__NumberRangeProcessor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NumberRangeProcessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UnitRangeProcessor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  std::string_view arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::UnitRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnitRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::UnitRangeProcessor *)new Xapian::UnitRangeProcessor(arg1,SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnitRangeProcessor, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitRangeProcessor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Xapian::UnitRangeProcessor *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnitRangeProcessor" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::UnitRangeProcessor *)new Xapian::UnitRangeProcessor(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__UnitRangeProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitRangeProcessor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnitRangeProcessor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_UnitRangeProcessor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_UnitRangeProcessor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnitRangeProcessor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::UnitRangeProcessor::UnitRangeProcessor(Xapian::valueno,std::string_view)\n"
    "    Xapian::UnitRangeProcessor::UnitRangeProcessor(Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnitRangeProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::UnitRangeProcessor *arg1 = (Xapian::UnitRangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__UnitRangeProcessor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitRangeProcessor" "', argument " "1"" of type '" "Xapian::UnitRangeProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::UnitRangeProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnitRangeProcessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__UnitRangeProcessor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UnitRangeProcessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FieldProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::FieldProcessor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::FieldProcessor *)new SwigDirector_FieldProcessor(arg1); 
        } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
          SWIG_fail;
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FieldProcessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FieldProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::FieldProcessor *arg1 = (Xapian::FieldProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__FieldProcessor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldProcessor" "', argument " "1"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::FieldProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldProcessor___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::FieldProcessor *arg1 = (Xapian::FieldProcessor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::Query result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "FieldProcessor___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldProcessor___call__" "', argument " "1"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::FieldProcessor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldProcessor___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldProcessor___call__" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::FieldProcessor::operator ()");
        } else {
          result = (arg1)->operator ()((std::string const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldProcessor_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::FieldProcessor *arg1 = (Xapian::FieldProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::FieldProcessor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldProcessor_release" "', argument " "1"" of type '" "Xapian::FieldProcessor const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::FieldProcessor * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::FieldProcessor *)((Xapian::FieldProcessor const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_FieldProcessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::FieldProcessor *arg1 = (Xapian::FieldProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_FieldProcessor" "', argument " "1"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::FieldProcessor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FieldProcessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__FieldProcessor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FieldProcessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QueryParser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_QueryParser", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::QueryParser *)new Xapian::QueryParser();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__QueryParser, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QueryParser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QueryParser" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_stemmer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Stem *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser_set_stemmer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_stemmer" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Stem,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QueryParser_set_stemmer" "', argument " "2"" of type '" "Xapian::Stem const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QueryParser_set_stemmer" "', argument " "2"" of type '" "Xapian::Stem const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Stem * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stemmer((Xapian::Stem const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_stemming_strategy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::QueryParser::stem_strategy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser_set_stemming_strategy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_stemming_strategy" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_stemming_strategy" "', argument " "2"" of type '" "Xapian::QueryParser::stem_strategy""'");
  } 
  arg2 = static_cast< Xapian::QueryParser::stem_strategy >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stemming_strategy(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_stopper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Stopper *arg2 = (Xapian::Stopper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_stopper" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__Stopper, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QueryParser_set_stopper" "', argument " "2"" of type '" "Xapian::Stopper const *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Stopper * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stopper((Xapian::Stopper const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_stopper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_stopper" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stopper();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_stopper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_set_stopper", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_QueryParser_set_stopper__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_QueryParser_set_stopper__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_set_stopper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::set_stopper(Xapian::Stopper const *)\n"
    "    Xapian::QueryParser::set_stopper()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_stopper_strategy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::QueryParser::stop_strategy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser_set_stopper_strategy", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_stopper_strategy" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_stopper_strategy" "', argument " "2"" of type '" "Xapian::QueryParser::stop_strategy""'");
  } 
  arg2 = static_cast< Xapian::QueryParser::stop_strategy >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_stopper_strategy(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_default_op(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Query::op arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser_set_default_op", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_default_op" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_default_op" "', argument " "2"" of type '" "Xapian::Query::op""'");
  } 
  arg2 = static_cast< Xapian::Query::op >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_default_op(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_get_default_op(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Query::op result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_get_default_op" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Query::op)((Xapian::QueryParser const *)arg1)->get_default_op();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_database(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Database *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser_set_database", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_database" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QueryParser_set_database" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QueryParser_set_database" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Database * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_database((Xapian::Database const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_max_expansion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::termcount arg2 ;
  int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_max_expansion" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_max_expansion" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QueryParser_set_max_expansion" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "QueryParser_set_max_expansion" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_max_expansion(arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_max_expansion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::termcount arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_max_expansion" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_max_expansion" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QueryParser_set_max_expansion" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_max_expansion(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_max_expansion__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::termcount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_max_expansion" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_max_expansion" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_max_expansion(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_max_expansion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_set_max_expansion", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_QueryParser_set_max_expansion__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_QueryParser_set_max_expansion__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_QueryParser_set_max_expansion__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_set_max_expansion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::set_max_expansion(Xapian::termcount,int,unsigned int)\n"
    "    Xapian::QueryParser::set_max_expansion(Xapian::termcount,int)\n"
    "    Xapian::QueryParser::set_max_expansion(Xapian::termcount)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_min_wildcard_prefix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_min_wildcard_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_min_wildcard_prefix" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QueryParser_set_min_wildcard_prefix" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_min_wildcard_prefix(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_min_wildcard_prefix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_set_min_wildcard_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryParser_set_min_wildcard_prefix" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_min_wildcard_prefix(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_set_min_wildcard_prefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_set_min_wildcard_prefix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_QueryParser_set_min_wildcard_prefix__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_QueryParser_set_min_wildcard_prefix__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_set_min_wildcard_prefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::set_min_wildcard_prefix(unsigned int,unsigned int)\n"
    "    Xapian::QueryParser::set_min_wildcard_prefix(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser_parse_query__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  Xapian::Query result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_parse_query" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QueryParser_parse_query" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->parse_query(SWIG_STD_MOVE(arg2),arg3,SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_parse_query__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::Query result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_parse_query" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QueryParser_parse_query" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->parse_query(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_parse_query__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::Query result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_parse_query" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->parse_query(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Query(result)), SWIGTYPE_p_Xapian__Query, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_parse_query(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_parse_query", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_QueryParser_parse_query__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_QueryParser_parse_query__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_QueryParser_parse_query__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_parse_query'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::parse_query(std::string_view,unsigned int,std::string_view)\n"
    "    Xapian::QueryParser::parse_query(std::string_view,unsigned int)\n"
    "    Xapian::QueryParser::parse_query(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_prefix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_prefix(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_prefix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  Xapian::FieldProcessor *arg3 = (Xapian::FieldProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QueryParser_add_prefix" "', argument " "3"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg3 = reinterpret_cast< Xapian::FieldProcessor * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_prefix(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_prefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_add_prefix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Xapian__FieldProcessor, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_QueryParser_add_prefix__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_QueryParser_add_prefix__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_add_prefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::add_prefix(std::string_view,std::string_view)\n"
    "    Xapian::QueryParser::add_prefix(std::string_view,Xapian::FieldProcessor *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  std::string *arg4 = (std::string *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_boolean_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    std::string *ptr = (std::string *)0;
    if (swig_obj[3] != Py_None) {
      res4 = XapianSWIG_anystring_as_ptr(swig_obj[3], &ptr);
      if (!SWIG_IsOK(res4)) {
        if (res4 == INT_MIN) SWIG_fail;
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QueryParser_add_boolean_prefix" "', argument " "4"" of type '" "std::string const *""'");
      }
    }
    arg4 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_prefix(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::string const *)arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_boolean_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_prefix(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  bool val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_boolean_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "QueryParser_add_boolean_prefix" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_prefix(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  Xapian::FieldProcessor *arg3 = (Xapian::FieldProcessor *) 0 ;
  std::string *arg4 = (std::string *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_boolean_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QueryParser_add_boolean_prefix" "', argument " "3"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg3 = reinterpret_cast< Xapian::FieldProcessor * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    if (swig_obj[3] != Py_None) {
      res4 = XapianSWIG_anystring_as_ptr(swig_obj[3], &ptr);
      if (!SWIG_IsOK(res4)) {
        if (res4 == INT_MIN) SWIG_fail;
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QueryParser_add_boolean_prefix" "', argument " "4"" of type '" "std::string const *""'");
      }
    }
    arg4 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_prefix(SWIG_STD_MOVE(arg2),arg3,(std::string const *)arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  Xapian::FieldProcessor *arg3 = (Xapian::FieldProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_boolean_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QueryParser_add_boolean_prefix" "', argument " "3"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg3 = reinterpret_cast< Xapian::FieldProcessor * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_prefix(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  Xapian::FieldProcessor *arg3 = (Xapian::FieldProcessor *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_boolean_prefix" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_Xapian__FieldProcessor, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QueryParser_add_boolean_prefix" "', argument " "3"" of type '" "Xapian::FieldProcessor *""'"); 
  }
  arg3 = reinterpret_cast< Xapian::FieldProcessor * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "QueryParser_add_boolean_prefix" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_boolean_prefix(SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_boolean_prefix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_add_boolean_prefix", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Xapian__FieldProcessor, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_QueryParser_add_boolean_prefix__SWIG_4(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_QueryParser_add_boolean_prefix__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Xapian__FieldProcessor, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      if (argv[3] == Py_None) {
        _v = 1;
      } else if (PyUnicode_Check(argv[3])) {
        _v = 1;
      } else if (PyBytes_Check(argv[3])) {
        _v = 1;
      } else {
        int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_QueryParser_add_boolean_prefix__SWIG_3(self, argc, argv);
  }
check_3:
  
  if (argc == 4) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Xapian__FieldProcessor, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_bool(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_QueryParser_add_boolean_prefix__SWIG_5(self, argc, argv);
  }
check_4:
  
  if (argc == 4) {
    int _v = 0;
    {
      if (argv[3] == Py_None) {
        _v = 1;
      } else if (PyUnicode_Check(argv[3])) {
        _v = 1;
      } else if (PyBytes_Check(argv[3])) {
        _v = 1;
      } else {
        int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_QueryParser_add_boolean_prefix__SWIG_0(self, argc, argv);
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_QueryParser_add_boolean_prefix__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_add_boolean_prefix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::add_boolean_prefix(std::string_view,std::string_view,std::string const *)\n"
    "    Xapian::QueryParser::add_boolean_prefix(std::string_view,std::string_view)\n"
    "    Xapian::QueryParser::add_boolean_prefix(std::string_view,std::string_view,bool)\n"
    "    Xapian::QueryParser::add_boolean_prefix(std::string_view,Xapian::FieldProcessor *,std::string const *)\n"
    "    Xapian::QueryParser::add_boolean_prefix(std::string_view,Xapian::FieldProcessor *)\n"
    "    Xapian::QueryParser::add_boolean_prefix(std::string_view,Xapian::FieldProcessor *,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser__stoplist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser__stoplist_begin" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::QueryParser const *)arg1)->stoplist_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser__stoplist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser__stoplist_end" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::QueryParser const *)arg1)->stoplist_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser__unstem_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser__unstem_begin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser__unstem_begin" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::QueryParser const *)arg1)->unstem_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser__unstem_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "QueryParser__unstem_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser__unstem_end" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::QueryParser const *)arg1)->unstem_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_rangeprocessor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::RangeProcessor *arg2 = (Xapian::RangeProcessor *) 0 ;
  std::string *arg3 = (std::string *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_rangeprocessor" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QueryParser_add_rangeprocessor" "', argument " "2"" of type '" "Xapian::RangeProcessor *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::RangeProcessor * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    if (swig_obj[2] != Py_None) {
      res3 = XapianSWIG_anystring_as_ptr(swig_obj[2], &ptr);
      if (!SWIG_IsOK(res3)) {
        if (res3 == INT_MIN) SWIG_fail;
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QueryParser_add_rangeprocessor" "', argument " "3"" of type '" "std::string const *""'");
      }
    }
    arg3 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_rangeprocessor(arg2,(std::string const *)arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_rangeprocessor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::RangeProcessor *arg2 = (Xapian::RangeProcessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_add_rangeprocessor" "', argument " "1"" of type '" "Xapian::QueryParser *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Xapian__RangeProcessor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QueryParser_add_rangeprocessor" "', argument " "2"" of type '" "Xapian::RangeProcessor *""'"); 
  }
  arg2 = reinterpret_cast< Xapian::RangeProcessor * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_rangeprocessor(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser_add_rangeprocessor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QueryParser_add_rangeprocessor", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_QueryParser_add_rangeprocessor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_QueryParser_add_rangeprocessor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QueryParser_add_rangeprocessor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::QueryParser::add_rangeprocessor(Xapian::RangeProcessor *,std::string const *)\n"
    "    Xapian::QueryParser::add_rangeprocessor(Xapian::RangeProcessor *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QueryParser_get_corrected_query_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser_get_corrected_query_string" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::QueryParser const *)arg1)->get_corrected_query_string();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QueryParser___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__QueryParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryParser___str__" "', argument " "1"" of type '" "Xapian::QueryParser const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::QueryParser * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::QueryParser const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QueryParser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__QueryParser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QueryParser_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_sortable_serialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sortable_serialise" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::sortable_serialise(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sortable_unserialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[0], &p, &len) < 0) SWIG_fail;
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)Xapian::sortable_unserialise(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueSetMatchDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  bool arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::ValueSetMatchDecider *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ValueSetMatchDecider", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ValueSetMatchDecider" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ValueSetMatchDecider" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ValueSetMatchDecider *)new Xapian::ValueSetMatchDecider(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValueSetMatchDecider, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueSetMatchDecider_add_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueSetMatchDecider *arg1 = (Xapian::ValueSetMatchDecider *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueSetMatchDecider_add_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueSetMatchDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueSetMatchDecider_add_value" "', argument " "1"" of type '" "Xapian::ValueSetMatchDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueSetMatchDecider * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ValueSetMatchDecider_add_value" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ValueSetMatchDecider_add_value" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_value((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueSetMatchDecider_remove_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueSetMatchDecider *arg1 = (Xapian::ValueSetMatchDecider *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueSetMatchDecider_remove_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueSetMatchDecider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueSetMatchDecider_remove_value" "', argument " "1"" of type '" "Xapian::ValueSetMatchDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueSetMatchDecider * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ValueSetMatchDecider_remove_value" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ValueSetMatchDecider_remove_value" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->remove_value((std::string const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ValueSetMatchDecider(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueSetMatchDecider *arg1 = (Xapian::ValueSetMatchDecider *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueSetMatchDecider, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValueSetMatchDecider" "', argument " "1"" of type '" "Xapian::ValueSetMatchDecider *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueSetMatchDecider * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValueSetMatchDecider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ValueSetMatchDecider, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ValueSetMatchDecider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Weight" "', argument " "1"" of type '" "Xapian::Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_name" "', argument " "1"" of type '" "Xapian::Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Weight const *)arg1)->name();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_get_sumpart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::termcount arg3 ;
  Xapian::termcount arg4 ;
  Xapian::termcount arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Weight_get_sumpart", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_get_sumpart" "', argument " "1"" of type '" "Xapian::Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Weight_get_sumpart" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Weight_get_sumpart" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Weight_get_sumpart" "', argument " "4"" of type '" "Xapian::termcount""'");
  } 
  arg4 = static_cast< Xapian::termcount >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Weight_get_sumpart" "', argument " "5"" of type '" "Xapian::termcount""'");
  } 
  arg5 = static_cast< Xapian::termcount >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::Weight const *)arg1)->get_sumpart(arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_get_maxpart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_get_maxpart" "', argument " "1"" of type '" "Xapian::Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::Weight const *)arg1)->get_maxpart();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_get_sumextra(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::termcount arg3 ;
  Xapian::termcount arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Weight_get_sumextra", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_get_sumextra" "', argument " "1"" of type '" "Xapian::Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Weight_get_sumextra" "', argument " "2"" of type '" "Xapian::termcount""'");
  } 
  arg2 = static_cast< Xapian::termcount >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Weight_get_sumextra" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Weight_get_sumextra" "', argument " "4"" of type '" "Xapian::termcount""'");
  } 
  arg4 = static_cast< Xapian::termcount >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::Weight const *)arg1)->get_sumextra(arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_get_maxextra(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_get_maxextra" "', argument " "1"" of type '" "Xapian::Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::Weight const *)arg1)->get_maxextra();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_create__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Xapian::Registry *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = XapianSWIG_anystring_as_ptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      if (res1 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_create" "', argument " "1"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Weight_create" "', argument " "1"" of type '" "std::string const &""'");
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Registry,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Weight_create" "', argument " "2"" of type '" "Xapian::Registry const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Weight_create" "', argument " "2"" of type '" "Xapian::Registry const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Registry * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Weight *)Xapian::Weight::create((std::string const &)*arg1,(Xapian::Registry const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_create__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Xapian::Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = XapianSWIG_anystring_as_ptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      if (res1 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_create" "', argument " "1"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Weight_create" "', argument " "1"" of type '" "std::string const &""'");
    }
    arg1 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Weight *)Xapian::Weight::create((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Weight_create(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Weight_create", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Weight_create__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Weight_create__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Weight_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Weight::create(std::string const &,Xapian::Registry const &)\n"
    "    Xapian::Weight::create(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Weight *)((Xapian::Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BoolWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BoolWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_BoolWeight", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BoolWeight *)new Xapian::BoolWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BoolWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::BoolWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BoolWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BoolWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::BoolWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BoolWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoolWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BoolWeight *)((Xapian::BoolWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BoolWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoolWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BoolWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoolWeight" "', argument " "1"" of type '" "Xapian::BoolWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BoolWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoolWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__BoolWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BoolWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TfIdfWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Xapian::TfIdfWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = XapianSWIG_anystring_as_ptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      if (res1 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TfIdfWeight" "', argument " "1"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TfIdfWeight" "', argument " "1"" of type '" "std::string const &""'");
    }
    arg1 = ptr;
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TfIdfWeight *)new Xapian::TfIdfWeight((std::string const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TfIdfWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Xapian::TfIdfWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = XapianSWIG_anystring_as_ptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      if (res1 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TfIdfWeight" "', argument " "1"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TfIdfWeight" "', argument " "1"" of type '" "std::string const &""'");
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TfIdfWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TfIdfWeight" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TfIdfWeight *)new Xapian::TfIdfWeight((std::string const &)*arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TfIdfWeight__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TfIdfWeight::wdf_norm arg1 ;
  Xapian::TfIdfWeight::idf_norm arg2 ;
  Xapian::TfIdfWeight::wt_norm arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::TfIdfWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TfIdfWeight" "', argument " "1"" of type '" "Xapian::TfIdfWeight::wdf_norm""'");
  } 
  arg1 = static_cast< Xapian::TfIdfWeight::wdf_norm >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TfIdfWeight" "', argument " "2"" of type '" "Xapian::TfIdfWeight::idf_norm""'");
  } 
  arg2 = static_cast< Xapian::TfIdfWeight::idf_norm >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TfIdfWeight" "', argument " "3"" of type '" "Xapian::TfIdfWeight::wt_norm""'");
  } 
  arg3 = static_cast< Xapian::TfIdfWeight::wt_norm >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TfIdfWeight *)new Xapian::TfIdfWeight(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TfIdfWeight__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::TfIdfWeight::wdf_norm arg1 ;
  Xapian::TfIdfWeight::idf_norm arg2 ;
  Xapian::TfIdfWeight::wt_norm arg3 ;
  double arg4 ;
  double arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Xapian::TfIdfWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TfIdfWeight" "', argument " "1"" of type '" "Xapian::TfIdfWeight::wdf_norm""'");
  } 
  arg1 = static_cast< Xapian::TfIdfWeight::wdf_norm >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TfIdfWeight" "', argument " "2"" of type '" "Xapian::TfIdfWeight::idf_norm""'");
  } 
  arg2 = static_cast< Xapian::TfIdfWeight::idf_norm >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TfIdfWeight" "', argument " "3"" of type '" "Xapian::TfIdfWeight::wt_norm""'");
  } 
  arg3 = static_cast< Xapian::TfIdfWeight::wt_norm >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TfIdfWeight" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TfIdfWeight" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TfIdfWeight *)new Xapian::TfIdfWeight(arg1,arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TfIdfWeight__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::TfIdfWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TfIdfWeight *)new Xapian::TfIdfWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TfIdfWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TfIdfWeight", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_TfIdfWeight__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_TfIdfWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_int(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    return _wrap_new_TfIdfWeight__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_TfIdfWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_TfIdfWeight__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TfIdfWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TfIdfWeight::TfIdfWeight(std::string const &)\n"
    "    Xapian::TfIdfWeight::TfIdfWeight(std::string const &,double,double)\n"
    "    Xapian::TfIdfWeight::TfIdfWeight(Xapian::TfIdfWeight::wdf_norm,Xapian::TfIdfWeight::idf_norm,Xapian::TfIdfWeight::wt_norm)\n"
    "    Xapian::TfIdfWeight::TfIdfWeight(Xapian::TfIdfWeight::wdf_norm,Xapian::TfIdfWeight::idf_norm,Xapian::TfIdfWeight::wt_norm,double,double)\n"
    "    Xapian::TfIdfWeight::TfIdfWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TfIdfWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TfIdfWeight *arg1 = (Xapian::TfIdfWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::TfIdfWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "TfIdfWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TfIdfWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TfIdfWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::TfIdfWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TfIdfWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TfIdfWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TfIdfWeight *)((Xapian::TfIdfWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TfIdfWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TfIdfWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TfIdfWeight *arg1 = (Xapian::TfIdfWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TfIdfWeight" "', argument " "1"" of type '" "Xapian::TfIdfWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TfIdfWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TfIdfWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__TfIdfWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TfIdfWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BM25Weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Xapian::BM25Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BM25Weight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BM25Weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BM25Weight" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BM25Weight" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BM25Weight" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BM25Weight *)new Xapian::BM25Weight(arg1,arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BM25Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BM25Weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::BM25Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BM25Weight *)new Xapian::BM25Weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BM25Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BM25Weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BM25Weight", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_BM25Weight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_BM25Weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BM25Weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::BM25Weight::BM25Weight(double,double,double,double,double)\n"
    "    Xapian::BM25Weight::BM25Weight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BM25Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::BM25Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BM25Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BM25Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BM25Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::BM25Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BM25Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BM25Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BM25Weight *)((Xapian::BM25Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BM25Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BM25Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BM25Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BM25Weight" "', argument " "1"" of type '" "Xapian::BM25Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BM25Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BM25Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__BM25Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BM25Weight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BM25PlusWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Xapian::BM25PlusWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BM25PlusWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BM25PlusWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BM25PlusWeight" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BM25PlusWeight" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BM25PlusWeight" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_BM25PlusWeight" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BM25PlusWeight *)new Xapian::BM25PlusWeight(arg1,arg2,arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BM25PlusWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BM25PlusWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::BM25PlusWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BM25PlusWeight *)new Xapian::BM25PlusWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BM25PlusWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BM25PlusWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BM25PlusWeight", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_BM25PlusWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_BM25PlusWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BM25PlusWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::BM25PlusWeight::BM25PlusWeight(double,double,double,double,double,double)\n"
    "    Xapian::BM25PlusWeight::BM25PlusWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BM25PlusWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BM25PlusWeight *arg1 = (Xapian::BM25PlusWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::BM25PlusWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BM25PlusWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BM25PlusWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BM25PlusWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::BM25PlusWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BM25PlusWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BM25PlusWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BM25PlusWeight *)((Xapian::BM25PlusWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BM25PlusWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BM25PlusWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BM25PlusWeight *arg1 = (Xapian::BM25PlusWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BM25PlusWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BM25PlusWeight" "', argument " "1"" of type '" "Xapian::BM25PlusWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BM25PlusWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BM25PlusWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__BM25PlusWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BM25PlusWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TradWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::TradWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TradWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TradWeight *)new Xapian::TradWeight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TradWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::TradWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::TradWeight *)new Xapian::TradWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__TradWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TradWeight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_TradWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_TradWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TradWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::TradWeight::TradWeight(double)\n"
    "    Xapian::TradWeight::TradWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__TradWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradWeight" "', argument " "1"" of type '" "Xapian::TradWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::TradWeight * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        delete arg1;
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__TradWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TradWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InL2Weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::InL2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InL2Weight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::InL2Weight *)new Xapian::InL2Weight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InL2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InL2Weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::InL2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::InL2Weight *)new Xapian::InL2Weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InL2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InL2Weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InL2Weight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_InL2Weight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_InL2Weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InL2Weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::InL2Weight::InL2Weight(double)\n"
    "    Xapian::InL2Weight::InL2Weight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InL2Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::InL2Weight *arg1 = (Xapian::InL2Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::InL2Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "InL2Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__InL2Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InL2Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::InL2Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::InL2Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InL2Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::InL2Weight *)((Xapian::InL2Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__InL2Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InL2Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::InL2Weight *arg1 = (Xapian::InL2Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__InL2Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InL2Weight" "', argument " "1"" of type '" "Xapian::InL2Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::InL2Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InL2Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__InL2Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InL2Weight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IfB2Weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::IfB2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IfB2Weight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::IfB2Weight *)new Xapian::IfB2Weight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__IfB2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IfB2Weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::IfB2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::IfB2Weight *)new Xapian::IfB2Weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__IfB2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IfB2Weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IfB2Weight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_IfB2Weight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IfB2Weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IfB2Weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::IfB2Weight::IfB2Weight(double)\n"
    "    Xapian::IfB2Weight::IfB2Weight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IfB2Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::IfB2Weight *arg1 = (Xapian::IfB2Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::IfB2Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IfB2Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__IfB2Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IfB2Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::IfB2Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::IfB2Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IfB2Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::IfB2Weight *)((Xapian::IfB2Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__IfB2Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IfB2Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::IfB2Weight *arg1 = (Xapian::IfB2Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__IfB2Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IfB2Weight" "', argument " "1"" of type '" "Xapian::IfB2Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::IfB2Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IfB2Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__IfB2Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IfB2Weight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IneB2Weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::IneB2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IneB2Weight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::IneB2Weight *)new Xapian::IneB2Weight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__IneB2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IneB2Weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::IneB2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::IneB2Weight *)new Xapian::IneB2Weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__IneB2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IneB2Weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IneB2Weight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_IneB2Weight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_IneB2Weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IneB2Weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::IneB2Weight::IneB2Weight(double)\n"
    "    Xapian::IneB2Weight::IneB2Weight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IneB2Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::IneB2Weight *arg1 = (Xapian::IneB2Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::IneB2Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "IneB2Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__IneB2Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IneB2Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::IneB2Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::IneB2Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IneB2Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::IneB2Weight *)((Xapian::IneB2Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__IneB2Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IneB2Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::IneB2Weight *arg1 = (Xapian::IneB2Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__IneB2Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IneB2Weight" "', argument " "1"" of type '" "Xapian::IneB2Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::IneB2Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IneB2Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__IneB2Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IneB2Weight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BB2Weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::BB2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BB2Weight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BB2Weight *)new Xapian::BB2Weight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BB2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BB2Weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::BB2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BB2Weight *)new Xapian::BB2Weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BB2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BB2Weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BB2Weight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_BB2Weight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_BB2Weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BB2Weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::BB2Weight::BB2Weight(double)\n"
    "    Xapian::BB2Weight::BB2Weight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BB2Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BB2Weight *arg1 = (Xapian::BB2Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::BB2Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "BB2Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BB2Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BB2Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::BB2Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BB2Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BB2Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::BB2Weight *)((Xapian::BB2Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__BB2Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BB2Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::BB2Weight *arg1 = (Xapian::BB2Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__BB2Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BB2Weight" "', argument " "1"" of type '" "Xapian::BB2Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::BB2Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BB2Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__BB2Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BB2Weight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DLHWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DLHWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_DLHWeight", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DLHWeight *)new Xapian::DLHWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DLHWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DLHWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DLHWeight *arg1 = (Xapian::DLHWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::DLHWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DLHWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DLHWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DLHWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::DLHWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DLHWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DLHWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DLHWeight *)((Xapian::DLHWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DLHWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DLHWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DLHWeight *arg1 = (Xapian::DLHWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DLHWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DLHWeight" "', argument " "1"" of type '" "Xapian::DLHWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DLHWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DLHWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DLHWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DLHWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PL2Weight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::PL2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PL2Weight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PL2Weight *)new Xapian::PL2Weight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PL2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PL2Weight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::PL2Weight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PL2Weight *)new Xapian::PL2Weight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PL2Weight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PL2Weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PL2Weight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_PL2Weight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_PL2Weight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PL2Weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::PL2Weight::PL2Weight(double)\n"
    "    Xapian::PL2Weight::PL2Weight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PL2Weight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PL2Weight *arg1 = (Xapian::PL2Weight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::PL2Weight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PL2Weight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PL2Weight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PL2Weight_create_from_parameters" "', argument " "1"" of type '" "Xapian::PL2Weight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PL2Weight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PL2Weight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PL2Weight *)((Xapian::PL2Weight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PL2Weight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PL2Weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PL2Weight *arg1 = (Xapian::PL2Weight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PL2Weight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PL2Weight" "', argument " "1"" of type '" "Xapian::PL2Weight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PL2Weight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PL2Weight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__PL2Weight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PL2Weight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PL2PlusWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Xapian::PL2PlusWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PL2PlusWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PL2PlusWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PL2PlusWeight *)new Xapian::PL2PlusWeight(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PL2PlusWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PL2PlusWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::PL2PlusWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PL2PlusWeight *)new Xapian::PL2PlusWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PL2PlusWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PL2PlusWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PL2PlusWeight", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_PL2PlusWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_PL2PlusWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PL2PlusWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::PL2PlusWeight::PL2PlusWeight(double,double)\n"
    "    Xapian::PL2PlusWeight::PL2PlusWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PL2PlusWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PL2PlusWeight *arg1 = (Xapian::PL2PlusWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::PL2PlusWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PL2PlusWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PL2PlusWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PL2PlusWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::PL2PlusWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PL2PlusWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PL2PlusWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PL2PlusWeight *)((Xapian::PL2PlusWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PL2PlusWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PL2PlusWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PL2PlusWeight *arg1 = (Xapian::PL2PlusWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PL2PlusWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PL2PlusWeight" "', argument " "1"" of type '" "Xapian::PL2PlusWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PL2PlusWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PL2PlusWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__PL2PlusWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PL2PlusWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DPHWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DPHWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_DPHWeight", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DPHWeight *)new Xapian::DPHWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DPHWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DPHWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DPHWeight *arg1 = (Xapian::DPHWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::DPHWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DPHWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DPHWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DPHWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::DPHWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DPHWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DPHWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DPHWeight *)((Xapian::DPHWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DPHWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DPHWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DPHWeight *arg1 = (Xapian::DPHWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DPHWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DPHWeight" "', argument " "1"" of type '" "Xapian::DPHWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DPHWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DPHWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DPHWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DPHWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LMJMWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::LMJMWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LMJMWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMJMWeight *)new Xapian::LMJMWeight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMJMWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMJMWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::LMJMWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMJMWeight *)new Xapian::LMJMWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMJMWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMJMWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LMJMWeight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_LMJMWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LMJMWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LMJMWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LMJMWeight::LMJMWeight(double)\n"
    "    Xapian::LMJMWeight::LMJMWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LMJMWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LMJMWeight *arg1 = (Xapian::LMJMWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::LMJMWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LMJMWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LMJMWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMJMWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::LMJMWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LMJMWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMJMWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMJMWeight *)((Xapian::LMJMWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMJMWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LMJMWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LMJMWeight *arg1 = (Xapian::LMJMWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LMJMWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LMJMWeight" "', argument " "1"" of type '" "Xapian::LMJMWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LMJMWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LMJMWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LMJMWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LMJMWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LMDirichletWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Xapian::LMDirichletWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LMDirichletWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LMDirichletWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMDirichletWeight *)new Xapian::LMDirichletWeight(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMDirichletWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMDirichletWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::LMDirichletWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LMDirichletWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMDirichletWeight *)new Xapian::LMDirichletWeight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMDirichletWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMDirichletWeight__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::LMDirichletWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMDirichletWeight *)new Xapian::LMDirichletWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMDirichletWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMDirichletWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LMDirichletWeight", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_LMDirichletWeight__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LMDirichletWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LMDirichletWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LMDirichletWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LMDirichletWeight::LMDirichletWeight(double,double)\n"
    "    Xapian::LMDirichletWeight::LMDirichletWeight(double)\n"
    "    Xapian::LMDirichletWeight::LMDirichletWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LMDirichletWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LMDirichletWeight *arg1 = (Xapian::LMDirichletWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::LMDirichletWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LMDirichletWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LMDirichletWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMDirichletWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::LMDirichletWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LMDirichletWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMDirichletWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMDirichletWeight *)((Xapian::LMDirichletWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMDirichletWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LMDirichletWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LMDirichletWeight *arg1 = (Xapian::LMDirichletWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LMDirichletWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LMDirichletWeight" "', argument " "1"" of type '" "Xapian::LMDirichletWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LMDirichletWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LMDirichletWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LMDirichletWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LMDirichletWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LMAbsDiscountWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::LMAbsDiscountWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LMAbsDiscountWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMAbsDiscountWeight *)new Xapian::LMAbsDiscountWeight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMAbsDiscountWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMAbsDiscountWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::LMAbsDiscountWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMAbsDiscountWeight *)new Xapian::LMAbsDiscountWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMAbsDiscountWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LMAbsDiscountWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LMAbsDiscountWeight", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_LMAbsDiscountWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LMAbsDiscountWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LMAbsDiscountWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LMAbsDiscountWeight::LMAbsDiscountWeight(double)\n"
    "    Xapian::LMAbsDiscountWeight::LMAbsDiscountWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LMAbsDiscountWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LMAbsDiscountWeight *arg1 = (Xapian::LMAbsDiscountWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::LMAbsDiscountWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LMAbsDiscountWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LMAbsDiscountWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMAbsDiscountWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::LMAbsDiscountWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LMAbsDiscountWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMAbsDiscountWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LMAbsDiscountWeight *)((Xapian::LMAbsDiscountWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LMAbsDiscountWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LMAbsDiscountWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LMAbsDiscountWeight *arg1 = (Xapian::LMAbsDiscountWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LMAbsDiscountWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LMAbsDiscountWeight" "', argument " "1"" of type '" "Xapian::LMAbsDiscountWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LMAbsDiscountWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LMAbsDiscountWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LMAbsDiscountWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LMAbsDiscountWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LM2StageWeight__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Xapian::LM2StageWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LM2StageWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LM2StageWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LM2StageWeight *)new Xapian::LM2StageWeight(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LM2StageWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LM2StageWeight__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::LM2StageWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LM2StageWeight" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LM2StageWeight *)new Xapian::LM2StageWeight(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LM2StageWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LM2StageWeight__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::LM2StageWeight *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LM2StageWeight *)new Xapian::LM2StageWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LM2StageWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LM2StageWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LM2StageWeight", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_LM2StageWeight__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LM2StageWeight__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LM2StageWeight__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LM2StageWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LM2StageWeight::LM2StageWeight(double,double)\n"
    "    Xapian::LM2StageWeight::LM2StageWeight(double)\n"
    "    Xapian::LM2StageWeight::LM2StageWeight()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LM2StageWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LM2StageWeight *arg1 = (Xapian::LM2StageWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::LM2StageWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LM2StageWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LM2StageWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LM2StageWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::LM2StageWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LM2StageWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LM2StageWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LM2StageWeight *)((Xapian::LM2StageWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LM2StageWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LM2StageWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LM2StageWeight *arg1 = (Xapian::LM2StageWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LM2StageWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LM2StageWeight" "', argument " "1"" of type '" "Xapian::LM2StageWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LM2StageWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LM2StageWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LM2StageWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LM2StageWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CoordWeight_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::CoordWeight *arg1 = (Xapian::CoordWeight *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CoordWeight_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__CoordWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordWeight_init" "', argument " "1"" of type '" "Xapian::CoordWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::CoordWeight * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordWeight_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->init(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoordWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::CoordWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_CoordWeight", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::CoordWeight *)new Xapian::CoordWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__CoordWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::CoordWeight *arg1 = (Xapian::CoordWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::CoordWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "CoordWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__CoordWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::CoordWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::CoordWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoordWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::CoordWeight *)((Xapian::CoordWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__CoordWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CoordWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::CoordWeight *arg1 = (Xapian::CoordWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__CoordWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoordWeight" "', argument " "1"" of type '" "Xapian::CoordWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::CoordWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CoordWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__CoordWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CoordWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DiceWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DiceWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_DiceWeight", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DiceWeight *)new Xapian::DiceWeight();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DiceWeight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiceWeight_create_from_parameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DiceWeight *arg1 = (Xapian::DiceWeight *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::DiceWeight *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DiceWeight_create_from_parameters", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DiceWeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiceWeight_create_from_parameters" "', argument " "1"" of type '" "Xapian::DiceWeight const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DiceWeight * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiceWeight_create_from_parameters" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DiceWeight *)((Xapian::DiceWeight const *)arg1)->create_from_parameters((char const *)arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DiceWeight, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DiceWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DiceWeight *arg1 = (Xapian::DiceWeight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DiceWeight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiceWeight" "', argument " "1"" of type '" "Xapian::DiceWeight *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DiceWeight * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiceWeight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DiceWeight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiceWeight_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Compactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Compactor *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::Compactor *)new SwigDirector_Compactor(arg1); 
        } else {
          result = (Xapian::Compactor *)new Xapian::Compactor(); 
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Compactor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Compactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Compactor *arg1 = (Xapian::Compactor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Compactor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Compactor" "', argument " "1"" of type '" "Xapian::Compactor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Compactor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compactor_set_status(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Compactor *arg1 = (Xapian::Compactor *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Compactor_set_status", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Compactor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compactor_set_status" "', argument " "1"" of type '" "Xapian::Compactor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Compactor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compactor_set_status" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compactor_set_status" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = XapianSWIG_anystring_as_ptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      if (res3 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Compactor_set_status" "', argument " "3"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compactor_set_status" "', argument " "3"" of type '" "std::string const &""'");
    }
    arg3 = ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::Compactor::set_status((std::string const &)*arg2,(std::string const &)*arg3);
        } else {
          (arg1)->set_status((std::string const &)*arg2,(std::string const &)*arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Compactor_resolve_duplicate_metadata(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Compactor *arg1 = (Xapian::Compactor *) 0 ;
  std::string *arg2 = 0 ;
  size_t arg3 ;
  std::string *arg4 = (std::string *) (std::string *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Compactor_resolve_duplicate_metadata", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Compactor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Compactor_resolve_duplicate_metadata" "', argument " "1"" of type '" "Xapian::Compactor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Compactor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Compactor_resolve_duplicate_metadata" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Compactor_resolve_duplicate_metadata" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Compactor_resolve_duplicate_metadata" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Compactor_resolve_duplicate_metadata" "', argument " "4"" of type '" "std::string const []""'"); 
  } 
  arg4 = reinterpret_cast< std::string * >(argp4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (arg1)->Xapian::Compactor::resolve_duplicate_metadata((std::string const &)*arg2,SWIG_STD_MOVE(arg3),(std::string const (*))arg4);
        } else {
          result = (arg1)->resolve_duplicate_metadata((std::string const &)*arg2,SWIG_STD_MOVE(arg3),(std::string const (*))arg4);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Compactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Compactor *arg1 = (Xapian::Compactor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Compactor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Compactor" "', argument " "1"" of type '" "Xapian::Compactor *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Compactor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Compactor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Compactor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Compactor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::PostingSource *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if ( arg1 != Py_None ) {
      /* subclassed */
      result = (Xapian::PostingSource *)new SwigDirector_PostingSource(arg1); 
    } else {
      SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
      SWIG_fail;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PostingSource" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_get_termfreq_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_get_termfreq_min" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::PostingSource::get_termfreq_min");
        } else {
          result = (Xapian::doccount)((Xapian::PostingSource const *)arg1)->get_termfreq_min();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_get_termfreq_est(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_get_termfreq_est" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::PostingSource::get_termfreq_est");
        } else {
          result = (Xapian::doccount)((Xapian::PostingSource const *)arg1)->get_termfreq_est();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_get_termfreq_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_get_termfreq_max" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::PostingSource::get_termfreq_max");
        } else {
          result = (Xapian::doccount)((Xapian::PostingSource const *)arg1)->get_termfreq_max();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_set_maxweight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostingSource_set_maxweight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_set_maxweight" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostingSource_set_maxweight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_maxweight(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_get_maxweight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_get_maxweight" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double)((Xapian::PostingSource const *)arg1)->get_maxweight();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_get_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_get_weight" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (double)((Xapian::PostingSource const *)arg1)->Xapian::PostingSource::get_weight();
        } else {
          result = (double)((Xapian::PostingSource const *)arg1)->get_weight();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_get_docid" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::PostingSource::get_docid");
        } else {
          result = (Xapian::docid)((Xapian::PostingSource const *)arg1)->get_docid();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostingSource___next__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource___next__" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostingSource___next__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::PostingSource::next");
        } else {
          (arg1)->next(arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_skip_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  Xapian::docid arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostingSource_skip_to", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_skip_to" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostingSource_skip_to" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PostingSource_skip_to" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::PostingSource::skip_to(arg2,arg3);
        } else {
          (arg1)->skip_to(arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  Xapian::docid arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostingSource_check", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_check" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PostingSource_check" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PostingSource_check" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Xapian::PostingSource::check(arg2,arg3);
        } else {
          result = (bool)(arg1)->check(arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_at_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_at_end" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::PostingSource::at_end");
        } else {
          result = (bool)((Xapian::PostingSource const *)arg1)->at_end();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_name" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::PostingSource const *)arg1)->Xapian::PostingSource::name();
        } else {
          result = ((Xapian::PostingSource const *)arg1)->name();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  Xapian::Database *arg2 = 0 ;
  Xapian::doccount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostingSource_reset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_reset" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostingSource_reset" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostingSource_reset" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Database * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PostingSource_reset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::PostingSource::reset((Xapian::Database const &)*arg2,arg3);
        } else {
          (arg1)->reset((Xapian::Database const &)*arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  Xapian::Database *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "PostingSource_init", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_init" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostingSource_init" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostingSource_init" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Database * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::PostingSource::init((Xapian::Database const &)*arg2);
        } else {
          (arg1)->init((Xapian::Database const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource___str__" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::PostingSource const *)arg1)->Xapian::PostingSource::get_description();
        } else {
          result = ((Xapian::PostingSource const *)arg1)->get_description();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PostingSource_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::PostingSource *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostingSource_release" "', argument " "1"" of type '" "Xapian::PostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::PostingSource *)((Xapian::PostingSource const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_PostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::PostingSource *arg1 = (Xapian::PostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__PostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PostingSource" "', argument " "1"" of type '" "Xapian::PostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::PostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__PostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ValuePostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Xapian::valueno arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::ValuePostingSource *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ValuePostingSource", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ValuePostingSource" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if ( arg1 != Py_None ) {
      /* subclassed */
      result = (Xapian::ValuePostingSource *)new SwigDirector_ValuePostingSource(arg1,arg2); 
    } else {
      result = (Xapian::ValuePostingSource *)new Xapian::ValuePostingSource(arg2); 
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValuePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_termfreq_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_termfreq_min" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Xapian::doccount)((Xapian::ValuePostingSource const *)arg1)->Xapian::ValuePostingSource::get_termfreq_min();
        } else {
          result = (Xapian::doccount)((Xapian::ValuePostingSource const *)arg1)->get_termfreq_min();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_termfreq_est(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_termfreq_est" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Xapian::doccount)((Xapian::ValuePostingSource const *)arg1)->Xapian::ValuePostingSource::get_termfreq_est();
        } else {
          result = (Xapian::doccount)((Xapian::ValuePostingSource const *)arg1)->get_termfreq_est();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_termfreq_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_termfreq_max" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Xapian::doccount)((Xapian::ValuePostingSource const *)arg1)->Xapian::ValuePostingSource::get_termfreq_max();
        } else {
          result = (Xapian::doccount)((Xapian::ValuePostingSource const *)arg1)->get_termfreq_max();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource___next__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource___next__" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValuePostingSource___next__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::ValuePostingSource::next(arg2);
        } else {
          (arg1)->next(arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_skip_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  Xapian::docid arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource_skip_to", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_skip_to" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValuePostingSource_skip_to" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ValuePostingSource_skip_to" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::ValuePostingSource::skip_to(arg2,arg3);
        } else {
          (arg1)->skip_to(arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  Xapian::docid arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource_check", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_check" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValuePostingSource_check" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ValuePostingSource_check" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)(arg1)->Xapian::ValuePostingSource::check(arg2,arg3);
        } else {
          result = (bool)(arg1)->check(arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_at_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_at_end" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (bool)((Xapian::ValuePostingSource const *)arg1)->Xapian::ValuePostingSource::at_end();
        } else {
          result = (bool)((Xapian::ValuePostingSource const *)arg1)->at_end();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_docid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_docid" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (Xapian::docid)((Xapian::ValuePostingSource const *)arg1)->Xapian::ValuePostingSource::get_docid();
        } else {
          result = (Xapian::docid)((Xapian::ValuePostingSource const *)arg1)->get_docid();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  Xapian::Database *arg2 = 0 ;
  Xapian::doccount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource_reset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_reset" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ValuePostingSource_reset" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ValuePostingSource_reset" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Database * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ValuePostingSource_reset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::ValuePostingSource::reset((Xapian::Database const &)*arg2,arg3);
        } else {
          (arg1)->reset((Xapian::Database const &)*arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_database(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Database result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_database" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ValuePostingSource const *)arg1)->get_database();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_slot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::valueno result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_slot" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::valueno)((Xapian::ValuePostingSource const *)arg1)->get_slot();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_value" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ValuePostingSource const *)arg1)->get_value();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_done(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_done" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->done();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_get_started(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_get_started" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::ValuePostingSource const *)arg1)->get_started();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_set_termfreq_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource_set_termfreq_min", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_set_termfreq_min" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValuePostingSource_set_termfreq_min" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_termfreq_min(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_set_termfreq_est(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource_set_termfreq_est", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_set_termfreq_est" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValuePostingSource_set_termfreq_est" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_termfreq_est(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource_set_termfreq_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  Xapian::doccount arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValuePostingSource_set_termfreq_max", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource_set_termfreq_max" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValuePostingSource_set_termfreq_max" "', argument " "2"" of type '" "Xapian::doccount""'");
  } 
  arg2 = static_cast< Xapian::doccount >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_termfreq_max(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValuePostingSource___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValuePostingSource___str__" "', argument " "1"" of type '" "Xapian::ValuePostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::ValuePostingSource const *)arg1)->Xapian::ValuePostingSource::get_description();
        } else {
          result = ((Xapian::ValuePostingSource const *)arg1)->get_description();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ValuePostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValuePostingSource" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_ValuePostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValuePostingSource *arg1 = (Xapian::ValuePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValuePostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ValuePostingSource" "', argument " "1"" of type '" "Xapian::ValuePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValuePostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValuePostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ValuePostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ValuePostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ValueWeightPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Xapian::valueno arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::ValueWeightPostingSource *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_ValueWeightPostingSource", 2, 2, swig_obj)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ValueWeightPostingSource" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::ValueWeightPostingSource *)new SwigDirector_ValueWeightPostingSource(arg1,arg2); 
        } else {
          result = (Xapian::ValueWeightPostingSource *)new Xapian::ValueWeightPostingSource(arg2); 
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValueWeightPostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueWeightPostingSource_get_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueWeightPostingSource *arg1 = (Xapian::ValueWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueWeightPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueWeightPostingSource_get_weight" "', argument " "1"" of type '" "Xapian::ValueWeightPostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueWeightPostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = (double)((Xapian::ValueWeightPostingSource const *)arg1)->Xapian::ValueWeightPostingSource::get_weight();
        } else {
          result = (double)((Xapian::ValueWeightPostingSource const *)arg1)->get_weight();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueWeightPostingSource_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueWeightPostingSource *arg1 = (Xapian::ValueWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueWeightPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueWeightPostingSource_name" "', argument " "1"" of type '" "Xapian::ValueWeightPostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueWeightPostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::ValueWeightPostingSource const *)arg1)->Xapian::ValueWeightPostingSource::name();
        } else {
          result = ((Xapian::ValueWeightPostingSource const *)arg1)->name();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueWeightPostingSource_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueWeightPostingSource *arg1 = (Xapian::ValueWeightPostingSource *) 0 ;
  Xapian::Database *arg2 = 0 ;
  Xapian::doccount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueWeightPostingSource_reset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueWeightPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueWeightPostingSource_reset" "', argument " "1"" of type '" "Xapian::ValueWeightPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueWeightPostingSource * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ValueWeightPostingSource_reset" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ValueWeightPostingSource_reset" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Database * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ValueWeightPostingSource_reset" "', argument " "3"" of type '" "Xapian::doccount""'");
  } 
  arg3 = static_cast< Xapian::doccount >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::ValueWeightPostingSource::reset((Xapian::Database const &)*arg2,arg3);
        } else {
          (arg1)->reset((Xapian::Database const &)*arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueWeightPostingSource___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueWeightPostingSource *arg1 = (Xapian::ValueWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueWeightPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueWeightPostingSource___str__" "', argument " "1"" of type '" "Xapian::ValueWeightPostingSource const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueWeightPostingSource * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::ValueWeightPostingSource const *)arg1)->Xapian::ValueWeightPostingSource::get_description();
        } else {
          result = ((Xapian::ValueWeightPostingSource const *)arg1)->get_description();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ValueWeightPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueWeightPostingSource *arg1 = (Xapian::ValueWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueWeightPostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValueWeightPostingSource" "', argument " "1"" of type '" "Xapian::ValueWeightPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueWeightPostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_ValueWeightPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueWeightPostingSource *arg1 = (Xapian::ValueWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueWeightPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ValueWeightPostingSource" "', argument " "1"" of type '" "Xapian::ValueWeightPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueWeightPostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValueWeightPostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ValueWeightPostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ValueWeightPostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DecreasingValueWeightPostingSource__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::docid arg2 ;
  Xapian::docid arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::DecreasingValueWeightPostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecreasingValueWeightPostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecreasingValueWeightPostingSource" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecreasingValueWeightPostingSource" "', argument " "3"" of type '" "Xapian::docid""'");
  } 
  arg3 = static_cast< Xapian::docid >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DecreasingValueWeightPostingSource *)new Xapian::DecreasingValueWeightPostingSource(arg1,arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DecreasingValueWeightPostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecreasingValueWeightPostingSource__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::docid arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::DecreasingValueWeightPostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecreasingValueWeightPostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecreasingValueWeightPostingSource" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DecreasingValueWeightPostingSource *)new Xapian::DecreasingValueWeightPostingSource(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DecreasingValueWeightPostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecreasingValueWeightPostingSource__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Xapian::DecreasingValueWeightPostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecreasingValueWeightPostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::DecreasingValueWeightPostingSource *)new Xapian::DecreasingValueWeightPostingSource(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__DecreasingValueWeightPostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecreasingValueWeightPostingSource(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DecreasingValueWeightPostingSource", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_DecreasingValueWeightPostingSource__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_DecreasingValueWeightPostingSource__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_DecreasingValueWeightPostingSource__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DecreasingValueWeightPostingSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPostingSource(Xapian::valueno,Xapian::docid,Xapian::docid)\n"
    "    Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPostingSource(Xapian::valueno,Xapian::docid)\n"
    "    Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPostingSource(Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DecreasingValueWeightPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::DecreasingValueWeightPostingSource *arg1 = (Xapian::DecreasingValueWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__DecreasingValueWeightPostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DecreasingValueWeightPostingSource" "', argument " "1"" of type '" "Xapian::DecreasingValueWeightPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::DecreasingValueWeightPostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DecreasingValueWeightPostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__DecreasingValueWeightPostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DecreasingValueWeightPostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ValueMapPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::ValueMapPostingSource *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ValueMapPostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ValueMapPostingSource *)new Xapian::ValueMapPostingSource(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValueMapPostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueMapPostingSource_add_mapping(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueMapPostingSource *arg1 = (Xapian::ValueMapPostingSource *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueMapPostingSource_add_mapping", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueMapPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueMapPostingSource_add_mapping" "', argument " "1"" of type '" "Xapian::ValueMapPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueMapPostingSource * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = XapianSWIG_anystring_as_ptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      if (res2 == INT_MIN) SWIG_fail;
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ValueMapPostingSource_add_mapping" "', argument " "2"" of type '" "std::string const &""'");
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ValueMapPostingSource_add_mapping" "', argument " "2"" of type '" "std::string const &""'");
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ValueMapPostingSource_add_mapping" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_mapping((std::string const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueMapPostingSource_clear_mappings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueMapPostingSource *arg1 = (Xapian::ValueMapPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueMapPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueMapPostingSource_clear_mappings" "', argument " "1"" of type '" "Xapian::ValueMapPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueMapPostingSource * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->clear_mappings();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueMapPostingSource_set_default_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueMapPostingSource *arg1 = (Xapian::ValueMapPostingSource *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueMapPostingSource_set_default_weight", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueMapPostingSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueMapPostingSource_set_default_weight" "', argument " "1"" of type '" "Xapian::ValueMapPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueMapPostingSource * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValueMapPostingSource_set_default_weight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_default_weight(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ValueMapPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueMapPostingSource *arg1 = (Xapian::ValueMapPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueMapPostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValueMapPostingSource" "', argument " "1"" of type '" "Xapian::ValueMapPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueMapPostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValueMapPostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ValueMapPostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ValueMapPostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FixedWeightPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::FixedWeightPostingSource *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FixedWeightPostingSource" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::FixedWeightPostingSource *)new Xapian::FixedWeightPostingSource(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__FixedWeightPostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedWeightPostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::FixedWeightPostingSource *arg1 = (Xapian::FixedWeightPostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__FixedWeightPostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedWeightPostingSource" "', argument " "1"" of type '" "Xapian::FixedWeightPostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::FixedWeightPostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedWeightPostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__FixedWeightPostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedWeightPostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MatchSpy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::MatchSpy *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if ( arg1 != Py_None ) {
      /* subclassed */
      result = (Xapian::MatchSpy *)new SwigDirector_MatchSpy(arg1); 
    } else {
      SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
      SWIG_fail;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MatchSpy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MatchSpy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatchSpy" "', argument " "1"" of type '" "Xapian::MatchSpy *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatchSpy___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  Xapian::Document *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MatchSpy___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatchSpy___call__" "', argument " "1"" of type '" "Xapian::MatchSpy *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatchSpy___call__" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatchSpy___call__" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Document * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatchSpy___call__" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::MatchSpy::operator ()");
        } else {
          (arg1)->operator ()((Xapian::Document const &)*arg2,arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatchSpy_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatchSpy_name" "', argument " "1"" of type '" "Xapian::MatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::MatchSpy const *)arg1)->Xapian::MatchSpy::name();
        } else {
          result = ((Xapian::MatchSpy const *)arg1)->name();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatchSpy_merge_results(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string bytes2 ;
  PyObject *swig_obj[2] ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "MatchSpy_merge_results", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatchSpy_merge_results" "', argument " "1"" of type '" "Xapian::MatchSpy *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[1], &p, &len) < 0) SWIG_fail;
    bytes2.assign(p, len);
    arg2 = &bytes2;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          (arg1)->Xapian::MatchSpy::merge_results((std::string const &)*arg2);
        } else {
          (arg1)->merge_results((std::string const &)*arg2);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatchSpy___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatchSpy___str__" "', argument " "1"" of type '" "Xapian::MatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          result = ((Xapian::MatchSpy const *)arg1)->Xapian::MatchSpy::get_description();
        } else {
          result = ((Xapian::MatchSpy const *)arg1)->get_description();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatchSpy_release(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  Xapian::MatchSpy *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatchSpy_release" "', argument " "1"" of type '" "Xapian::MatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::MatchSpy *)((Xapian::MatchSpy const *)arg1)->release();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    SWIG_Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_MatchSpy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::MatchSpy *arg1 = (Xapian::MatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__MatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MatchSpy" "', argument " "1"" of type '" "Xapian::MatchSpy *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::MatchSpy * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatchSpy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__MatchSpy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MatchSpy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ValueCountMatchSpy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ValueCountMatchSpy *)new Xapian::ValueCountMatchSpy();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValueCountMatchSpy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueCountMatchSpy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Xapian::ValueCountMatchSpy *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ValueCountMatchSpy" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::ValueCountMatchSpy *)new Xapian::ValueCountMatchSpy(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__ValueCountMatchSpy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueCountMatchSpy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ValueCountMatchSpy", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_ValueCountMatchSpy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ValueCountMatchSpy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ValueCountMatchSpy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::ValueCountMatchSpy::ValueCountMatchSpy()\n"
    "    Xapian::ValueCountMatchSpy::ValueCountMatchSpy(Xapian::valueno)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ValueCountMatchSpy_get_total(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *arg1 = (Xapian::ValueCountMatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueCountMatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueCountMatchSpy_get_total" "', argument " "1"" of type '" "Xapian::ValueCountMatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueCountMatchSpy * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::ValueCountMatchSpy const *)arg1)->get_total();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueCountMatchSpy_values_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *arg1 = (Xapian::ValueCountMatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueCountMatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueCountMatchSpy_values_begin" "', argument " "1"" of type '" "Xapian::ValueCountMatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueCountMatchSpy * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ValueCountMatchSpy const *)arg1)->values_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueCountMatchSpy_values_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *arg1 = (Xapian::ValueCountMatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueCountMatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueCountMatchSpy_values_end" "', argument " "1"" of type '" "Xapian::ValueCountMatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueCountMatchSpy * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::ValueCountMatchSpy const *)arg1)->values_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueCountMatchSpy_top_values_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *arg1 = (Xapian::ValueCountMatchSpy *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueCountMatchSpy_top_values_begin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueCountMatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueCountMatchSpy_top_values_begin" "', argument " "1"" of type '" "Xapian::ValueCountMatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueCountMatchSpy * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValueCountMatchSpy_top_values_begin" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::ValueCountMatchSpy const *)arg1)->top_values_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ValueCountMatchSpy_top_values_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *arg1 = (Xapian::ValueCountMatchSpy *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ValueCountMatchSpy_top_values_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueCountMatchSpy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ValueCountMatchSpy_top_values_end" "', argument " "1"" of type '" "Xapian::ValueCountMatchSpy const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueCountMatchSpy * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ValueCountMatchSpy_top_values_end" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::ValueCountMatchSpy const *)arg1)->top_values_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ValueCountMatchSpy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::ValueCountMatchSpy *arg1 = (Xapian::ValueCountMatchSpy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__ValueCountMatchSpy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValueCountMatchSpy" "', argument " "1"" of type '" "Xapian::ValueCountMatchSpy *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::ValueCountMatchSpy * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValueCountMatchSpy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__ValueCountMatchSpy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ValueCountMatchSpy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_miles_to_metres(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "miles_to_metres" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double)Xapian::miles_to_metres(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_metres_to_miles(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "metres_to_miles" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double)Xapian::metres_to_miles(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoord_latitude_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoord_latitude_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord_latitude_set" "', argument " "1"" of type '" "Xapian::LatLongCoord *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LatLongCoord_latitude_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->latitude = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoord_latitude_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord_latitude_get" "', argument " "1"" of type '" "Xapian::LatLongCoord *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double) ((arg1)->latitude);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoord_longitude_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoord_longitude_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord_longitude_set" "', argument " "1"" of type '" "Xapian::LatLongCoord *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LatLongCoord_longitude_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->longitude = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoord_longitude_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord_longitude_get" "', argument " "1"" of type '" "Xapian::LatLongCoord *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (double) ((arg1)->longitude);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongCoord__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Xapian::LatLongCoord *)new Xapian::LatLongCoord();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongCoord, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongCoord__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Xapian::LatLongCoord *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongCoord" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LatLongCoord" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongCoord *)new Xapian::LatLongCoord(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongCoord, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongCoord(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LatLongCoord", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_LatLongCoord__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LatLongCoord__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LatLongCoord'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LatLongCoord::LatLongCoord()\n"
    "    Xapian::LatLongCoord::LatLongCoord(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LatLongCoord_unserialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoord_unserialise", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord_unserialise" "', argument " "1"" of type '" "Xapian::LatLongCoord *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[1], &p, &len) < 0) SWIG_fail;
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->unserialise(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoord_serialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord_serialise" "', argument " "1"" of type '" "Xapian::LatLongCoord const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoord const *)arg1)->serialise();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoord___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoord___str__" "', argument " "1"" of type '" "Xapian::LatLongCoord const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoord const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LatLongCoord(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = (Xapian::LatLongCoord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoord, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LatLongCoord" "', argument " "1"" of type '" "Xapian::LatLongCoord *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LatLongCoord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LatLongCoord, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LatLongCoord_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LatLongCoordsIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_LatLongCoordsIterator", 0, 0, 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongCoordsIterator *)new Xapian::LatLongCoordsIterator();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongCoordsIterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoordsIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *arg1 = (Xapian::LatLongCoordsIterator *) 0 ;
  Xapian::LatLongCoordsIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoordsIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoordsIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoordsIterator___eq__" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoordsIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongCoordsIterator___eq__" "', argument " "2"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongCoordsIterator___eq__" "', argument " "2"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::LatLongCoordsIterator const *)arg1)->operator ==((Xapian::LatLongCoordsIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_LatLongCoordsIterator_equals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *arg1 = (Xapian::LatLongCoordsIterator *) 0 ;
  Xapian::LatLongCoordsIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoordsIterator_equals", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoordsIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoordsIterator_equals" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoordsIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongCoordsIterator_equals" "', argument " "2"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongCoordsIterator_equals" "', argument " "2"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian_LatLongCoordsIterator_equals((Xapian::LatLongCoordsIterator const *)arg1,(Xapian::LatLongCoordsIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoordsIterator_get_coord(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *arg1 = (Xapian::LatLongCoordsIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::LatLongCoord result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoordsIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoordsIterator_get_coord" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian_LatLongCoordsIterator_get_coord((Xapian::LatLongCoordsIterator const *)arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::LatLongCoord(result)), SWIGTYPE_p_Xapian__LatLongCoord, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoordsIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *arg1 = (Xapian::LatLongCoordsIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoordsIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoordsIterator___next__" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        Xapian_LatLongCoordsIterator_next(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LatLongCoordsIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *arg1 = (Xapian::LatLongCoordsIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoordsIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LatLongCoordsIterator" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LatLongCoordsIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LatLongCoordsIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LatLongCoordsIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_LatLongCoords_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::LatLongCoordsIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_begin" "', argument " "1"" of type '" "Xapian::LatLongCoords const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoords const *)arg1)->begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::LatLongCoordsIterator(result)), SWIGTYPE_p_Xapian__LatLongCoordsIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoords_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::LatLongCoordsIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_end" "', argument " "1"" of type '" "Xapian::LatLongCoords const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoords const *)arg1)->end();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::LatLongCoordsIterator(result)), SWIGTYPE_p_Xapian__LatLongCoordsIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoords_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_size" "', argument " "1"" of type '" "Xapian::LatLongCoords const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoords const *)arg1)->size();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoords_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_empty" "', argument " "1"" of type '" "Xapian::LatLongCoords const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::LatLongCoords const *)arg1)->empty();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoords_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  Xapian::LatLongCoord *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoords_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_append" "', argument " "1"" of type '" "Xapian::LatLongCoords *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongCoords_append" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongCoords_append" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoord * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->append((Xapian::LatLongCoord const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongCoords__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongCoords *)new Xapian::LatLongCoords();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongCoords, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongCoords__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoord *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::LatLongCoords *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LatLongCoords" "', argument " "1"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongCoords" "', argument " "1"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoord * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongCoords *)new Xapian::LatLongCoords((Xapian::LatLongCoord const &)*arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongCoords, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongCoords(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LatLongCoords", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_LatLongCoords__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_LatLongCoords__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LatLongCoords'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LatLongCoords::LatLongCoords()\n"
    "    Xapian::LatLongCoords::LatLongCoords(Xapian::LatLongCoord const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LatLongCoords_unserialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongCoords_unserialise", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_unserialise" "', argument " "1"" of type '" "Xapian::LatLongCoords *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    char * p;
    Py_ssize_t len;
    if (PyBytes_AsStringAndSize(swig_obj[1], &p, &len) < 0) SWIG_fail;
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->unserialise(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoords_serialise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords_serialise" "', argument " "1"" of type '" "Xapian::LatLongCoords const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoords const *)arg1)->serialise();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongCoords___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongCoords___str__" "', argument " "1"" of type '" "Xapian::LatLongCoords const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::LatLongCoords const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LatLongCoords(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoords *arg1 = (Xapian::LatLongCoords *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongCoords, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LatLongCoords" "', argument " "1"" of type '" "Xapian::LatLongCoords *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoords * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LatLongCoords_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LatLongCoords, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LatLongCoords_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___ne____SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::LatLongCoordsIterator *arg1 = 0 ;
  Xapian::LatLongCoordsIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xapian__LatLongCoordsIterator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoordsIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "Xapian::LatLongCoordsIterator const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoordsIterator * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)Xapian::operator !=((Xapian::LatLongCoordsIterator const &)*arg1,(Xapian::LatLongCoordsIterator const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__ne__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___ne____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap___ne____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap___ne____SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap___ne____SWIG_3(self, argc, argv);
  }
check_4:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__MSetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap___ne____SWIG_4(self, argc, argv);
  }
check_5:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__ESetIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap___ne____SWIG_5(self, argc, argv);
  }
check_6:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___ne____SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_LatLongMetric(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LatLongMetric" "', argument " "1"" of type '" "Xapian::LatLongMetric *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongMetric_pointwise_distance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  Xapian::LatLongCoord *arg2 = 0 ;
  Xapian::LatLongCoord *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "LatLongMetric_pointwise_distance", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongMetric_pointwise_distance" "', argument " "1"" of type '" "Xapian::LatLongMetric const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongMetric_pointwise_distance" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongMetric_pointwise_distance" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoord * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LatLongMetric_pointwise_distance" "', argument " "3"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongMetric_pointwise_distance" "', argument " "3"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongCoord * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::LatLongMetric::pointwise_distance");
        } else {
          result = (double)((Xapian::LatLongMetric const *)arg1)->pointwise_distance((Xapian::LatLongCoord const &)*arg2,(Xapian::LatLongCoord const &)*arg3);
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongMetric___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongCoords *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongMetric___call__" "', argument " "1"" of type '" "Xapian::LatLongMetric const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongMetric___call__" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongMetric___call__" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LatLongMetric___call__" "', argument " "3"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongMetric___call__" "', argument " "3"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongCoords * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::LatLongMetric const *)arg1)->operator ()((Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongCoords const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongMetric___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *bytes3 = NULL ;
  double result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongMetric___call__" "', argument " "1"" of type '" "Xapian::LatLongMetric const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongMetric___call__" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongMetric___call__" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::LatLongMetric const *)arg1)->operator ()((Xapian::LatLongCoords const &)*arg2,SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongMetric___call____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongMetric___call__" "', argument " "1"" of type '" "Xapian::LatLongMetric const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LatLongMetric___call__" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LatLongMetric___call__" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LatLongMetric___call__" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LatLongMetric___call__" "', argument " "4"" of type '" "size_t""'");
  } 
  arg4 = static_cast< size_t >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::LatLongMetric const *)arg1)->operator ()((Xapian::LatLongCoords const &)*arg2,(char const *)arg3,SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LatLongMetric___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LatLongMetric___call__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Xapian__LatLongCoords, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_LatLongMetric___call____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_LatLongMetric___call____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_LatLongMetric___call____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LatLongMetric___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LatLongMetric::operator ()(Xapian::LatLongCoords const &,Xapian::LatLongCoords const &) const\n"
    "    Xapian::LatLongMetric::operator ()(Xapian::LatLongCoords const &,std::string_view) const\n"
    "    Xapian::LatLongMetric::operator ()(Xapian::LatLongCoords const &,char const *,size_t) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LatLongMetric_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LatLongMetric_name" "', argument " "1"" of type '" "Xapian::LatLongMetric const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==swig_obj[0]));
  try {
    {
      try {
        if (upcall) {
          Swig::DirectorPureVirtualException::raise("Xapian::LatLongMetric::name");
        } else {
          result = ((Xapian::LatLongMetric const *)arg1)->name();
        }
      } catch (...) {
        Xapian::SetPythonException();
        SWIG_fail;
      }
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongMetric(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  Xapian::LatLongMetric *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        if ( arg1 != Py_None ) {
          /* subclassed */
          result = (Xapian::LatLongMetric *)new SwigDirector_LatLongMetric(arg1); 
        } else {
          SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
          SWIG_fail;
        }
        
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongMetric, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_LatLongMetric(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongMetric *arg1 = (Xapian::LatLongMetric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongMetric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_LatLongMetric" "', argument " "1"" of type '" "Xapian::LatLongMetric *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongMetric * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LatLongMetric_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LatLongMetric, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LatLongMetric_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GreatCircleMetric__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::GreatCircleMetric *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::GreatCircleMetric *)new Xapian::GreatCircleMetric();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__GreatCircleMetric, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GreatCircleMetric__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Xapian::GreatCircleMetric *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GreatCircleMetric" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::GreatCircleMetric *)new Xapian::GreatCircleMetric(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__GreatCircleMetric, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GreatCircleMetric(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GreatCircleMetric", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_GreatCircleMetric__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_GreatCircleMetric__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GreatCircleMetric'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::GreatCircleMetric::GreatCircleMetric()\n"
    "    Xapian::GreatCircleMetric::GreatCircleMetric(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GreatCircleMetric(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::GreatCircleMetric *arg1 = (Xapian::GreatCircleMetric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__GreatCircleMetric, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GreatCircleMetric" "', argument " "1"" of type '" "Xapian::GreatCircleMetric *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::GreatCircleMetric * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GreatCircleMetric_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__GreatCircleMetric, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GreatCircleMetric_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistancePostingSource" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LatLongDistancePostingSource" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LatLongDistancePostingSource" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongMetric const &)*arg3,arg4,arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistancePostingSource" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LatLongDistancePostingSource" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongMetric const &)*arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  double arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistancePostingSource" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongMetric const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongMetric const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistancePostingSource" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LatLongDistancePostingSource" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistancePostingSource" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  double arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LatLongDistancePostingSource" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::LatLongDistancePostingSource *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistancePostingSource" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistancePostingSource *)new Xapian::LatLongDistancePostingSource(arg1,(Xapian::LatLongCoords const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistancePostingSource(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LatLongDistancePostingSource", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Xapian__LatLongMetric, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_LatLongDistancePostingSource__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Xapian__LatLongMetric, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Xapian__LatLongMetric, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_6:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_LatLongDistancePostingSource__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LatLongDistancePostingSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,Xapian::LatLongMetric const &,double,double,double)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,Xapian::LatLongMetric const &,double,double)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,Xapian::LatLongMetric const &,double)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,Xapian::LatLongMetric const &)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,double,double,double)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,double,double)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &,double)\n"
    "    Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno,Xapian::LatLongCoords const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LatLongDistancePostingSource(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongDistancePostingSource *arg1 = (Xapian::LatLongDistancePostingSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LatLongDistancePostingSource" "', argument " "1"" of type '" "Xapian::LatLongDistancePostingSource *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongDistancePostingSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LatLongDistancePostingSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LatLongDistancePostingSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LatLongDistancePostingSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  double arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Xapian::LatLongDistanceKeyMaker *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistanceKeyMaker *)new Xapian::LatLongDistanceKeyMaker(arg1,(Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongMetric const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Xapian::LatLongDistanceKeyMaker *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistanceKeyMaker *)new Xapian::LatLongDistanceKeyMaker(arg1,(Xapian::LatLongCoords const &)*arg2,(Xapian::LatLongMetric const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoords *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::LatLongDistanceKeyMaker *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoords,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoords const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoords * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistanceKeyMaker *)new Xapian::LatLongDistanceKeyMaker(arg1,(Xapian::LatLongCoords const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoord *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  double arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Xapian::LatLongDistanceKeyMaker *result = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoord * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistanceKeyMaker *)new Xapian::LatLongDistanceKeyMaker(arg1,(Xapian::LatLongCoord const &)*arg2,(Xapian::LatLongMetric const &)*arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoord *arg2 = 0 ;
  Xapian::LatLongMetric *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Xapian::LatLongDistanceKeyMaker *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoord * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__LatLongMetric,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "3"" of type '" "Xapian::LatLongMetric const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::LatLongMetric * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistanceKeyMaker *)new Xapian::LatLongDistanceKeyMaker(arg1,(Xapian::LatLongCoord const &)*arg2,(Xapian::LatLongMetric const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::valueno arg1 ;
  Xapian::LatLongCoord *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Xapian::LatLongDistanceKeyMaker *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::valueno""'");
  } 
  arg1 = static_cast< Xapian::valueno >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__LatLongCoord,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LatLongDistanceKeyMaker" "', argument " "2"" of type '" "Xapian::LatLongCoord const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::LatLongCoord * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::LatLongDistanceKeyMaker *)new Xapian::LatLongDistanceKeyMaker(arg1,(Xapian::LatLongCoord const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LatLongDistanceKeyMaker(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LatLongDistanceKeyMaker", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__LatLongCoords, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_LatLongDistanceKeyMaker__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_LatLongDistanceKeyMaker__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__LatLongCoord, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_new_LatLongDistanceKeyMaker__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_LatLongDistanceKeyMaker__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xapian__LatLongCoords, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_new_LatLongDistanceKeyMaker__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_LatLongDistanceKeyMaker__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LatLongDistanceKeyMaker'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno,Xapian::LatLongCoords const &,Xapian::LatLongMetric const &,double)\n"
    "    Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno,Xapian::LatLongCoords const &,Xapian::LatLongMetric const &)\n"
    "    Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno,Xapian::LatLongCoords const &)\n"
    "    Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno,Xapian::LatLongCoord const &,Xapian::LatLongMetric const &,double)\n"
    "    Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno,Xapian::LatLongCoord const &,Xapian::LatLongMetric const &)\n"
    "    Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno,Xapian::LatLongCoord const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LatLongDistanceKeyMaker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::LatLongDistanceKeyMaker *arg1 = (Xapian::LatLongDistanceKeyMaker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LatLongDistanceKeyMaker" "', argument " "1"" of type '" "Xapian::LatLongDistanceKeyMaker *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::LatLongDistanceKeyMaker * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LatLongDistanceKeyMaker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__LatLongDistanceKeyMaker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LatLongDistanceKeyMaker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Database_add_database(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::Database *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_add_database", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_add_database" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Database,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Database_add_database" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Database_add_database" "', argument " "2"" of type '" "Xapian::Database const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Database * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_database((Xapian::Database const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_size" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->size();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Database__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::Database *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Database *)new Xapian::Database();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Database__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::Database *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Database" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Database *)new Xapian::Database(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Database__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::Database *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Database *)new Xapian::Database(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Database__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::Database *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Database" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Database" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Database *)new Xapian::Database(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Database__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Xapian::Database *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Database" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::Database *)new Xapian::Database(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Database(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Database", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_Database__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_Database__SWIG_4(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_Database__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_new_Database__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_Database__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Database'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::Database()\n"
    "    Xapian::Database::Database(std::string_view,int)\n"
    "    Xapian::Database::Database(std::string_view)\n"
    "    Xapian::Database::Database(int,int)\n"
    "    Xapian::Database::Database(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Database(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Database" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_reopen(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_reopen" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)(arg1)->reopen();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_close" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->close();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database___str__" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_description();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__postlist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::PostingIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__postlist_begin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__postlist_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->postlist_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PostingIterator(result)), SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__postlist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::PostingIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__postlist_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__postlist_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->postlist_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PostingIterator(result)), SWIGTYPE_p_Xapian__PostingIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__termlist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__termlist_begin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__termlist_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database__termlist_begin" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->termlist_begin(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__termlist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__termlist_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__termlist_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database__termlist_end" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->termlist_end(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_has_positions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_has_positions" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::Database const *)arg1)->has_positions();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__positionlist_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  PyObject *swig_obj[3] ;
  Xapian::PositionIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__positionlist_begin", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__positionlist_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database__positionlist_begin" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->positionlist_begin(arg2,SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PositionIterator(result)), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__positionlist_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *bytes3 = NULL ;
  PyObject *swig_obj[3] ;
  Xapian::PositionIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__positionlist_end", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__positionlist_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database__positionlist_end" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->positionlist_end(arg2,SWIG_STD_MOVE(arg3));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::PositionIterator(result)), SWIGTYPE_p_Xapian__PositionIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__allterms_begin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__allterms_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->allterms_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__allterms_begin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__allterms_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->allterms_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__allterms_begin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database__allterms_begin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database__allterms_begin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database__allterms_begin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database__allterms_begin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::allterms_begin(std::string_view) const\n"
    "    Xapian::Database::allterms_begin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database__allterms_end__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__allterms_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->allterms_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__allterms_end__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__allterms_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->allterms_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__allterms_end(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database__allterms_end", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database__allterms_end__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database__allterms_end__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database__allterms_end'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::allterms_end(std::string_view) const\n"
    "    Xapian::Database::allterms_end() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_get_doccount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::doccount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_doccount" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::Database const *)arg1)->get_doccount();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_lastdocid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::docid result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_lastdocid" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)((Xapian::Database const *)arg1)->get_lastdocid();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_average_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_average_length" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::Database const *)arg1)->get_average_length();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_avlength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_avlength" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (double)((Xapian::Database const *)arg1)->get_avlength();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_total_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::totallength result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_total_length" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::totallength)((Xapian::Database const *)arg1)->get_total_length();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_termfreq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::doccount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_termfreq", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_termfreq" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::Database const *)arg1)->get_termfreq(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_term_exists(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  bool result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_term_exists", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_term_exists" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::Database const *)arg1)->term_exists(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_collection_freq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::termcount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_collection_freq", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_collection_freq" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_collection_freq(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_value_freq(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::doccount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_value_freq", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_value_freq" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_value_freq" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::doccount)((Xapian::Database const *)arg1)->get_value_freq(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_value_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_value_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_value_lower_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_value_lower_bound" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_value_lower_bound(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_value_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_value_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_value_upper_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_value_upper_bound" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_value_upper_bound(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_doclength_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_doclength_lower_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_doclength_lower_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_doclength_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_doclength_upper_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_doclength_upper_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_wdf_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::termcount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_wdf_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_wdf_upper_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_wdf_upper_bound(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_unique_terms_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_unique_terms_lower_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_unique_terms_lower_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_unique_terms_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::termcount result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_unique_terms_upper_bound" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_unique_terms_upper_bound();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_valuestream_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::ValueIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_valuestream_begin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_valuestream_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_valuestream_begin" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->valuestream_begin(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ValueIterator(result)), SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_valuestream_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::valueno arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::ValueIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_valuestream_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_valuestream_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_valuestream_end" "', argument " "2"" of type '" "Xapian::valueno""'");
  } 
  arg2 = static_cast< Xapian::valueno >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->valuestream_end(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::ValueIterator(result)), SWIGTYPE_p_Xapian__ValueIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_doclength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::termcount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_doclength", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_doclength" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_doclength" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_doclength(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_unique_terms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::termcount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_unique_terms", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_unique_terms" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_unique_terms" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_unique_terms(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_wdfdocmax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::termcount result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_wdfdocmax", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_wdfdocmax" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_wdfdocmax" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_wdfdocmax(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_keep_alive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_keep_alive" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->keep_alive();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_document__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::Document result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_document" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_document" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_get_document" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_document(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Document(result)), SWIGTYPE_p_Xapian__Document, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_document__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::Document result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_document" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_get_document" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_document(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Document(result)), SWIGTYPE_p_Xapian__Document, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_document(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database_get_document", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Database_get_document__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Database_get_document__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database_get_document'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::get_document(Xapian::docid,unsigned int) const\n"
    "    Xapian::Database::get_document(Xapian::docid) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_get_spelling_suggestion__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_spelling_suggestion" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_get_spelling_suggestion" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_spelling_suggestion(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_spelling_suggestion__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_spelling_suggestion" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_spelling_suggestion(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_spelling_suggestion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database_get_spelling_suggestion", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Database_get_spelling_suggestion__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Database_get_spelling_suggestion__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database_get_spelling_suggestion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::get_spelling_suggestion(std::string_view,unsigned int) const\n"
    "    Xapian::Database::get_spelling_suggestion(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database__spellings_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__spellings_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->spellings_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__spellings_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__spellings_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->spellings_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonyms_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__synonyms_begin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__synonyms_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->synonyms_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonyms_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  Xapian::TermIterator result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database__synonyms_end", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__synonyms_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->synonyms_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonym_keys_begin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__synonym_keys_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->synonym_keys_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonym_keys_begin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__synonym_keys_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->synonym_keys_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonym_keys_begin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database__synonym_keys_begin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database__synonym_keys_begin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database__synonym_keys_begin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database__synonym_keys_begin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::synonym_keys_begin(std::string_view) const\n"
    "    Xapian::Database::synonym_keys_begin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database__synonym_keys_end__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__synonym_keys_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->synonym_keys_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonym_keys_end__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__synonym_keys_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->synonym_keys_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__synonym_keys_end(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database__synonym_keys_end", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database__synonym_keys_end__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database__synonym_keys_end__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database__synonym_keys_end'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::synonym_keys_end(std::string_view) const\n"
    "    Xapian::Database::synonym_keys_end() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_get_metadata(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "Database_get_metadata", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_metadata" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_metadata(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__metadata_keys_begin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__metadata_keys_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->metadata_keys_begin(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__metadata_keys_begin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__metadata_keys_begin" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->metadata_keys_begin();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__metadata_keys_begin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database__metadata_keys_begin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database__metadata_keys_begin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database__metadata_keys_begin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database__metadata_keys_begin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::metadata_keys_begin(std::string_view) const\n"
    "    Xapian::Database::metadata_keys_begin() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database__metadata_keys_end__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__metadata_keys_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->metadata_keys_end(SWIG_STD_MOVE(arg2));
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__metadata_keys_end__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::TermIterator result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database__metadata_keys_end" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((Xapian::Database const *)arg1)->metadata_keys_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Xapian::TermIterator(result)), SWIGTYPE_p_Xapian__TermIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database__metadata_keys_end(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database__metadata_keys_end", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database__metadata_keys_end__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database__metadata_keys_end__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database__metadata_keys_end'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::metadata_keys_end(std::string_view) const\n"
    "    Xapian::Database::metadata_keys_end() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_get_uuid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_uuid" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->get_uuid();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_locked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_locked" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (bool)((Xapian::Database const *)arg1)->locked();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_lock__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_lock" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_lock" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->lock(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_lock__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_lock" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->lock();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_lock(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database_lock", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_Database_lock__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_Database_lock__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database_lock'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::lock(int)\n"
    "    Xapian::Database::lock()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_unlock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::Database result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_unlock" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (arg1)->unlock();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_get_revision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Xapian::rev result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_get_revision" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::rev)((Xapian::Database const *)arg1)->get_revision();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_check__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_check" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Database::check(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_check__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  size_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Database::check(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_check__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Database_check" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_check" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Database::check(arg1,arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_check__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Database_check" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Database::check(arg1);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_check(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database_check", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Database_check__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_Database_check__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_Database_check__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Database_check__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database_check'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::check(std::string_view,int)\n"
    "    Xapian::Database::check(std::string_view)\n"
    "    Xapian::Database::check(int,int)\n"
    "    Xapian::Database::check(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_compact" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Database_compact" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_compact" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_compact" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_compact" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Database_compact" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_compact" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_compact" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_compact" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  Xapian::Compactor *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_compact" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Database_compact" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Xapian__Compactor,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Database_compact" "', argument " "5"" of type '" "Xapian::Compactor &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Database_compact" "', argument " "5"" of type '" "Xapian::Compactor &""'"); 
  }
  arg5 = reinterpret_cast< Xapian::Compactor * >(argp5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(SWIG_STD_MOVE(arg2),arg3,arg4,*arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  Xapian::Compactor *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_compact" "', argument " "1"" of type '" "Xapian::Database *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_compact" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_compact" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Database_compact" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Xapian__Compactor,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Database_compact" "', argument " "5"" of type '" "Xapian::Compactor &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Database_compact" "', argument " "5"" of type '" "Xapian::Compactor &""'"); 
  }
  arg5 = reinterpret_cast< Xapian::Compactor * >(argp5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->compact(arg2,arg3,arg4,*arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_compact(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database_compact", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_Database_compact__SWIG_5(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_Database_compact__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_Database_compact__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_Database_compact__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_Database_compact__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_Database_compact__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_7;
    PyObject *retobj = _wrap_Database_compact__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_7:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_Database_compact__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database_compact'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::compact(std::string_view,unsigned int,int)\n"
    "    Xapian::Database::compact(std::string_view,unsigned int)\n"
    "    Xapian::Database::compact(std::string_view)\n"
    "    Xapian::Database::compact(int,unsigned int,int)\n"
    "    Xapian::Database::compact(int,unsigned int)\n"
    "    Xapian::Database::compact(int)\n"
    "    Xapian::Database::compact(std::string_view,unsigned int,int,Xapian::Compactor &)\n"
    "    Xapian::Database::compact(int,unsigned int,int,Xapian::Compactor &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Database_reconstruct_text__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  size_t arg3 ;
  std::string_view arg4 ;
  Xapian::termpos arg5 ;
  Xapian::termpos arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_reconstruct_text" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_reconstruct_text" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_reconstruct_text" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Database_reconstruct_text" "', argument " "5"" of type '" "Xapian::termpos""'");
  } 
  arg5 = static_cast< Xapian::termpos >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Database_reconstruct_text" "', argument " "6"" of type '" "Xapian::termpos""'");
  } 
  arg6 = static_cast< Xapian::termpos >(val6);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->reconstruct_text(arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_reconstruct_text__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  size_t arg3 ;
  std::string_view arg4 ;
  Xapian::termpos arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_reconstruct_text" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_reconstruct_text" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_reconstruct_text" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Database_reconstruct_text" "', argument " "5"" of type '" "Xapian::termpos""'");
  } 
  arg5 = static_cast< Xapian::termpos >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->reconstruct_text(arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_reconstruct_text__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  size_t arg3 ;
  std::string_view arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *bytes4 = NULL ;
  std::string result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_reconstruct_text" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_reconstruct_text" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_reconstruct_text" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[3]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[3]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[3])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[3], &len, &bytes4);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[3]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[3]);
    }
#endif
    arg4 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->reconstruct_text(arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  
  SWIG_Py_XDECREF(bytes4);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes4);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_reconstruct_text__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_reconstruct_text" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_reconstruct_text" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Database_reconstruct_text" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->reconstruct_text(arg2,SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_reconstruct_text__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__Database, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Database_reconstruct_text" "', argument " "1"" of type '" "Xapian::Database const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::Database * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Database_reconstruct_text" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = ((Xapian::Database const *)arg1)->reconstruct_text(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  
  resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Database_reconstruct_text(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Database_reconstruct_text", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_Database_reconstruct_text__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_Database_reconstruct_text__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_Database_reconstruct_text__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_Database_reconstruct_text__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_Database_reconstruct_text__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Database_reconstruct_text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Database::reconstruct_text(Xapian::docid,size_t,std::string_view,Xapian::termpos,Xapian::termpos) const\n"
    "    Xapian::Database::reconstruct_text(Xapian::docid,size_t,std::string_view,Xapian::termpos) const\n"
    "    Xapian::Database::reconstruct_text(Xapian::docid,size_t,std::string_view) const\n"
    "    Xapian::Database::reconstruct_text(Xapian::docid,size_t) const\n"
    "    Xapian::Database::reconstruct_text(Xapian::docid) const\n");
  return 0;
}


SWIGINTERN PyObject *Database_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__Database, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Database_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_WritableDatabase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_add_database(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::WritableDatabase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "WritableDatabase_add_database", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_add_database" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__WritableDatabase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WritableDatabase_add_database" "', argument " "2"" of type '" "Xapian::WritableDatabase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WritableDatabase_add_database" "', argument " "2"" of type '" "Xapian::WritableDatabase const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::WritableDatabase * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->add_database((Xapian::WritableDatabase const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WritableDatabase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  int arg3 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Xapian::WritableDatabase *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_WritableDatabase" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_WritableDatabase" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase(SWIG_STD_MOVE(arg1),arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WritableDatabase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  int arg2 ;
  PyObject *bytes1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  Xapian::WritableDatabase *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_WritableDatabase" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WritableDatabase__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  PyObject *bytes1 = NULL ;
  Xapian::WritableDatabase *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase(SWIG_STD_MOVE(arg1));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_NEW |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WritableDatabase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_WritableDatabase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_WritableDatabase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_WritableDatabase__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_WritableDatabase__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_WritableDatabase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WritableDatabase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WritableDatabase::WritableDatabase()\n"
    "    Xapian::WritableDatabase::WritableDatabase(std::string_view,int,int)\n"
    "    Xapian::WritableDatabase::WritableDatabase(std::string_view,int)\n"
    "    Xapian::WritableDatabase::WritableDatabase(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_commit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_commit" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->commit();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_begin_transaction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_begin_transaction" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WritableDatabase_begin_transaction" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->begin_transaction(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_begin_transaction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_begin_transaction" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->begin_transaction();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_begin_transaction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WritableDatabase_begin_transaction", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_WritableDatabase_begin_transaction__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_WritableDatabase_begin_transaction__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WritableDatabase_begin_transaction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WritableDatabase::begin_transaction(bool)\n"
    "    Xapian::WritableDatabase::begin_transaction()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_commit_transaction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_commit_transaction" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->commit_transaction();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_cancel_transaction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_cancel_transaction" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->cancel_transaction();
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_add_document(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::Document *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Xapian::docid result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "WritableDatabase_add_document", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_add_document" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WritableDatabase_add_document" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WritableDatabase_add_document" "', argument " "2"" of type '" "Xapian::Document const &""'"); 
  }
  arg2 = reinterpret_cast< Xapian::Document * >(argp2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)(arg1)->add_document((Xapian::Document const &)*arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_delete_document__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::docid arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_delete_document" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WritableDatabase_delete_document" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->delete_document(arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_delete_document__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_delete_document" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->delete_document(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_delete_document(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WritableDatabase_delete_document", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_WritableDatabase_delete_document__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_WritableDatabase_delete_document__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WritableDatabase_delete_document'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WritableDatabase::delete_document(Xapian::docid)\n"
    "    Xapian::WritableDatabase::delete_document(std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_replace_document__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::docid arg2 ;
  Xapian::Document *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_replace_document" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WritableDatabase_replace_document" "', argument " "2"" of type '" "Xapian::docid""'");
  } 
  arg2 = static_cast< Xapian::docid >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WritableDatabase_replace_document" "', argument " "3"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WritableDatabase_replace_document" "', argument " "3"" of type '" "Xapian::Document const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::Document * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->replace_document(arg2,(Xapian::Document const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_replace_document__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  Xapian::Document *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Xapian::docid result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_replace_document" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Xapian__Document,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WritableDatabase_replace_document" "', argument " "3"" of type '" "Xapian::Document const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WritableDatabase_replace_document" "', argument " "3"" of type '" "Xapian::Document const &""'"); 
  }
  arg3 = reinterpret_cast< Xapian::Document * >(argp3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::docid)(arg1)->replace_document(SWIG_STD_MOVE(arg2),(Xapian::Document const &)*arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_replace_document(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WritableDatabase_replace_document", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_WritableDatabase_replace_document__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_WritableDatabase_replace_document__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WritableDatabase_replace_document'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WritableDatabase::replace_document(Xapian::docid,Xapian::Document const &)\n"
    "    Xapian::WritableDatabase::replace_document(std::string_view,Xapian::Document const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_add_spelling__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_add_spelling" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WritableDatabase_add_spelling" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::WritableDatabase const *)arg1)->add_spelling(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_add_spelling__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_add_spelling" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::WritableDatabase const *)arg1)->add_spelling(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_add_spelling(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WritableDatabase_add_spelling", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_WritableDatabase_add_spelling__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_WritableDatabase_add_spelling__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WritableDatabase_add_spelling'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WritableDatabase::add_spelling(std::string_view,Xapian::termcount) const\n"
    "    Xapian::WritableDatabase::add_spelling(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_remove_spelling__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  Xapian::termcount arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::termcount result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_remove_spelling" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WritableDatabase_remove_spelling" "', argument " "3"" of type '" "Xapian::termcount""'");
  } 
  arg3 = static_cast< Xapian::termcount >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::WritableDatabase const *)arg1)->remove_spelling(SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_remove_spelling__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  Xapian::termcount result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_remove_spelling" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = (Xapian::termcount)((Xapian::WritableDatabase const *)arg1)->remove_spelling(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_remove_spelling(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "WritableDatabase_remove_spelling", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_WritableDatabase_remove_spelling__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_WritableDatabase_remove_spelling__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'WritableDatabase_remove_spelling'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::WritableDatabase::remove_spelling(std::string_view,Xapian::termcount) const\n"
    "    Xapian::WritableDatabase::remove_spelling(std::string_view) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_add_synonym(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "WritableDatabase_add_synonym", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_add_synonym" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::WritableDatabase const *)arg1)->add_synonym(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_remove_synonym(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "WritableDatabase_remove_synonym", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_remove_synonym" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::WritableDatabase const *)arg1)->remove_synonym(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_clear_synonyms(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "WritableDatabase_clear_synonyms", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_clear_synonyms" "', argument " "1"" of type '" "Xapian::WritableDatabase const *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        ((Xapian::WritableDatabase const *)arg1)->clear_synonyms(SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_WritableDatabase_set_metadata(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string_view arg2 ;
  std::string_view arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *bytes2 = NULL ;
  PyObject *bytes3 = NULL ;
  PyObject *swig_obj[3] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "WritableDatabase_set_metadata", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WritableDatabase_set_metadata" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[2]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[2]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[2])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[2], &len, &bytes3);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[2]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[2]);
    }
#endif
    arg3 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        (arg1)->set_metadata(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes2);
  
  
  SWIG_Py_XDECREF(bytes3);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_WritableDatabase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WritableDatabase" "', argument " "1"" of type '" "Xapian::WritableDatabase *""'"); 
  }
  arg1 = reinterpret_cast< Xapian::WritableDatabase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WritableDatabase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xapian__WritableDatabase, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *WritableDatabase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_remote_open__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Xapian::Database result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "remote_open" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::Database result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open(SWIG_STD_MOVE(arg1),arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::Database result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  int arg5 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open_writable" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open_writable" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "remote_open_writable" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "remote_open_writable" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open_writable" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open_writable" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "remote_open_writable" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open_writable" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open_writable" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),arg2,arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  unsigned int arg2 ;
  PyObject *bytes1 = NULL ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remote_open_writable" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),arg2);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::Database result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::Database result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::Database(result)), SWIGTYPE_p_Xapian__Database, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "remote_open", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_remote_open__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_remote_open__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_remote_open__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_remote_open__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_remote_open__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'remote_open'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Remote::open(std::string_view,unsigned int,unsigned int,unsigned int)\n"
    "    Xapian::Remote::open(std::string_view,unsigned int,unsigned int)\n"
    "    Xapian::Remote::open(std::string_view,unsigned int)\n"
    "    Xapian::Remote::open(std::string_view,std::string_view,unsigned int)\n"
    "    Xapian::Remote::open(std::string_view,std::string_view)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open_writable" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "remote_open_writable" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  unsigned int arg3 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "remote_open_writable" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string_view arg1 ;
  std::string_view arg2 ;
  PyObject *bytes1 = NULL ;
  PyObject *bytes2 = NULL ;
  Xapian::WritableDatabase result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[0]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[0]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[0])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[0], &len, &bytes1);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[0]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[0]);
    }
#endif
    arg1 = std::string_view(p, len);
  }
  {
    Py_ssize_t len;
#ifdef SWIG_PYTHON_STRICT_BYTE_CHAR
    const char *p = PyBytes_AsString(swig_obj[1]);
    if (!p) SWIG_fail;
    len = PyBytes_Size(swig_obj[1]);
#else
    const char *p;
    if (PyUnicode_Check(swig_obj[1])) {
      p = SWIG_PyUnicode_AsUTF8AndSize(swig_obj[1], &len, &bytes2);
      if (!p) SWIG_fail;
    } else {
      p = PyBytes_AsString(swig_obj[1]);
      if (!p) SWIG_fail;
      len = PyBytes_Size(swig_obj[1]);
    }
#endif
    arg2 = std::string_view(p, len);
  }
  {
    try {
      {
        SWIG_PYTHON_THREAD_BEGIN_ALLOW;
        result = Xapian::Remote::open_writable(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
        SWIG_PYTHON_THREAD_END_ALLOW;
      }
    } catch (...) {
      Xapian::SetPythonException();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new Xapian::WritableDatabase(result)), SWIGTYPE_p_Xapian__WritableDatabase, SWIG_POINTER_OWN |  0 );
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return resultobj;
fail:
  
  SWIG_Py_XDECREF(bytes1);
  
  
  SWIG_Py_XDECREF(bytes2);
  
  return NULL;
}


SWIGINTERN PyObject *_wrap_remote_open_writable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "remote_open_writable", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_remote_open_writable__SWIG_3(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_remote_open_writable__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_remote_open_writable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_remote_open_writable__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap_remote_open_writable__SWIG_1(self, argc, argv);
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_remote_open_writable__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_remote_open_writable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'remote_open_writable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xapian::Remote::open_writable(std::string_view,unsigned int,unsigned int,unsigned int,int)\n"
    "    Xapian::Remote::open_writable(std::string_view,unsigned int,unsigned int,unsigned int)\n"
    "    Xapian::Remote::open_writable(std::string_view,unsigned int,unsigned int)\n"
    "    Xapian::Remote::open_writable(std::string_view,unsigned int)\n"
    "    Xapian::Remote::open_writable(std::string_view,std::string_view,unsigned int,int)\n"
    "    Xapian::Remote::open_writable(std::string_view,std::string_view,unsigned int)\n"
    "    Xapian::Remote::open_writable(std::string_view,std::string_view)\n");
  return 0;
}


static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "Error_get_type", _wrap_Error_get_type, METH_O, "\n"
		"\n"
		"\n"
		"The type of this error (e.g. \"DocNotFoundError\".).\n"
		"\n"
		"const char * Xapian::Error::get_type() const noexcept\n"
		"Xapian::Error::get_type\n"
		""},
	 { "Error_get_msg", _wrap_Error_get_msg, METH_O, "\n"
		"\n"
		"\n"
		"Message giving details of the error, intended for human consumption.\n"
		"\n"
		"const std::string & Xapian::Error::get_msg() const noexcept\n"
		"Xapian::Error::get_msg\n"
		""},
	 { "Error_get_context", _wrap_Error_get_context, METH_O, "\n"
		"\n"
		"\n"
		"Optional context information.\n"
		"\n"
		"const std::string & Xapian::Error::get_context() const noexcept\n"
		"Xapian::Error::get_context This context is intended for machine use\n"
		"(for example to know which remote server an error came from), but it\n"
		"is typically a plain-text string, and so also fit for human\n"
		"consumption. \n"
		""},
	 { "Error_get_error_string", _wrap_Error_get_error_string, METH_O, "\n"
		"\n"
		"\n"
		"Returns any system error string associated with this exception.\n"
		"\n"
		"const char * Xapian::Error::get_error_string() const\n"
		"Xapian::Error::get_error_string The system error string may come from\n"
		"errno, h_errno (on UNIX), or GetLastError() (on MS Windows). If there\n"
		"is no associated system error string, NULL is returned. \n"
		""},
	 { "Error___str__", _wrap_Error___str__, METH_O, NULL},
	 { "delete_Error", _wrap_delete_Error, METH_O, NULL},
	 { "Error_swigregister", Error_swigregister, METH_O, NULL},
	 { "delete_LogicError", _wrap_delete_LogicError, METH_O, NULL},
	 { "LogicError_swigregister", LogicError_swigregister, METH_O, NULL},
	 { "delete_RuntimeError", _wrap_delete_RuntimeError, METH_O, NULL},
	 { "RuntimeError_swigregister", RuntimeError_swigregister, METH_O, NULL},
	 { "new_AssertionError", _wrap_new_AssertionError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::AssertionError::AssertionError(std::string_view msg_, int\n"
		"errno_) Xapian::AssertionError::AssertionError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_AssertionError", _wrap_delete_AssertionError, METH_O, NULL},
	 { "AssertionError_swigregister", AssertionError_swigregister, METH_O, NULL},
	 { "AssertionError_swiginit", AssertionError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArgumentError", _wrap_new_InvalidArgumentError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view\n"
		"msg_, int errno_) Xapian::InvalidArgumentError::InvalidArgumentError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_InvalidArgumentError", _wrap_delete_InvalidArgumentError, METH_O, NULL},
	 { "InvalidArgumentError_swigregister", InvalidArgumentError_swigregister, METH_O, NULL},
	 { "InvalidArgumentError_swiginit", InvalidArgumentError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidOperationError", _wrap_new_InvalidOperationError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::InvalidOperationError::InvalidOperationError(std::string_view\n"
		"msg_, int errno_) Xapian::InvalidOperationError::InvalidOperationError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_InvalidOperationError", _wrap_delete_InvalidOperationError, METH_O, NULL},
	 { "InvalidOperationError_swigregister", InvalidOperationError_swigregister, METH_O, NULL},
	 { "InvalidOperationError_swiginit", InvalidOperationError_swiginit, METH_VARARGS, NULL},
	 { "new_UnimplementedError", _wrap_new_UnimplementedError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::UnimplementedError::UnimplementedError(std::string_view msg_,\n"
		"int errno_) Xapian::UnimplementedError::UnimplementedError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_UnimplementedError", _wrap_delete_UnimplementedError, METH_O, NULL},
	 { "UnimplementedError_swigregister", UnimplementedError_swigregister, METH_O, NULL},
	 { "UnimplementedError_swiginit", UnimplementedError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseError", _wrap_new_DatabaseError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseError::DatabaseError(std::string_view msg_, int\n"
		"errno_) Xapian::DatabaseError::DatabaseError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseError", _wrap_delete_DatabaseError, METH_O, NULL},
	 { "DatabaseError_swigregister", DatabaseError_swigregister, METH_O, NULL},
	 { "DatabaseError_swiginit", DatabaseError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseCorruptError", _wrap_new_DatabaseCorruptError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseCorruptError::DatabaseCorruptError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseCorruptError", _wrap_delete_DatabaseCorruptError, METH_O, NULL},
	 { "DatabaseCorruptError_swigregister", DatabaseCorruptError_swigregister, METH_O, NULL},
	 { "DatabaseCorruptError_swiginit", DatabaseCorruptError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseCreateError", _wrap_new_DatabaseCreateError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseCreateError::DatabaseCreateError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseCreateError", _wrap_delete_DatabaseCreateError, METH_O, NULL},
	 { "DatabaseCreateError_swigregister", DatabaseCreateError_swigregister, METH_O, NULL},
	 { "DatabaseCreateError_swiginit", DatabaseCreateError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseLockError", _wrap_new_DatabaseLockError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseLockError::DatabaseLockError(std::string_view msg_,\n"
		"int errno_) Xapian::DatabaseLockError::DatabaseLockError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseLockError", _wrap_delete_DatabaseLockError, METH_O, NULL},
	 { "DatabaseLockError_swigregister", DatabaseLockError_swigregister, METH_O, NULL},
	 { "DatabaseLockError_swiginit", DatabaseLockError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseModifiedError", _wrap_new_DatabaseModifiedError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseModifiedError::DatabaseModifiedError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseModifiedError", _wrap_delete_DatabaseModifiedError, METH_O, NULL},
	 { "DatabaseModifiedError_swigregister", DatabaseModifiedError_swigregister, METH_O, NULL},
	 { "DatabaseModifiedError_swiginit", DatabaseModifiedError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseOpeningError", _wrap_new_DatabaseOpeningError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseOpeningError::DatabaseOpeningError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseOpeningError", _wrap_delete_DatabaseOpeningError, METH_O, NULL},
	 { "DatabaseOpeningError_swigregister", DatabaseOpeningError_swigregister, METH_O, NULL},
	 { "DatabaseOpeningError_swiginit", DatabaseOpeningError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseVersionError", _wrap_new_DatabaseVersionError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseVersionError::DatabaseVersionError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseVersionError", _wrap_delete_DatabaseVersionError, METH_O, NULL},
	 { "DatabaseVersionError_swigregister", DatabaseVersionError_swigregister, METH_O, NULL},
	 { "DatabaseVersionError_swiginit", DatabaseVersionError_swiginit, METH_VARARGS, NULL},
	 { "new_DocNotFoundError", _wrap_new_DocNotFoundError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DocNotFoundError::DocNotFoundError(std::string_view msg_, int\n"
		"errno_) Xapian::DocNotFoundError::DocNotFoundError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DocNotFoundError", _wrap_delete_DocNotFoundError, METH_O, NULL},
	 { "DocNotFoundError_swigregister", DocNotFoundError_swigregister, METH_O, NULL},
	 { "DocNotFoundError_swiginit", DocNotFoundError_swiginit, METH_VARARGS, NULL},
	 { "new_FeatureUnavailableError", _wrap_new_FeatureUnavailableError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view\n"
		"msg_, int errno_)\n"
		"Xapian::FeatureUnavailableError::FeatureUnavailableError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_FeatureUnavailableError", _wrap_delete_FeatureUnavailableError, METH_O, NULL},
	 { "FeatureUnavailableError_swigregister", FeatureUnavailableError_swigregister, METH_O, NULL},
	 { "FeatureUnavailableError_swiginit", FeatureUnavailableError_swiginit, METH_VARARGS, NULL},
	 { "new_InternalError", _wrap_new_InternalError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::InternalError::InternalError(std::string_view msg_, int\n"
		"errno_) Xapian::InternalError::InternalError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_InternalError", _wrap_delete_InternalError, METH_O, NULL},
	 { "InternalError_swigregister", InternalError_swigregister, METH_O, NULL},
	 { "InternalError_swiginit", InternalError_swiginit, METH_VARARGS, NULL},
	 { "new_NetworkError", _wrap_new_NetworkError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::NetworkError::NetworkError(std::string_view msg_, int errno_)\n"
		"Xapian::NetworkError::NetworkError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_NetworkError", _wrap_delete_NetworkError, METH_O, NULL},
	 { "NetworkError_swigregister", NetworkError_swigregister, METH_O, NULL},
	 { "NetworkError_swiginit", NetworkError_swiginit, METH_VARARGS, NULL},
	 { "new_NetworkTimeoutError", _wrap_new_NetworkTimeoutError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view\n"
		"msg_, int errno_) Xapian::NetworkTimeoutError::NetworkTimeoutError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_NetworkTimeoutError", _wrap_delete_NetworkTimeoutError, METH_O, NULL},
	 { "NetworkTimeoutError_swigregister", NetworkTimeoutError_swigregister, METH_O, NULL},
	 { "NetworkTimeoutError_swiginit", NetworkTimeoutError_swiginit, METH_VARARGS, NULL},
	 { "new_QueryParserError", _wrap_new_QueryParserError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::QueryParserError::QueryParserError(std::string_view msg_, int\n"
		"errno_) Xapian::QueryParserError::QueryParserError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_QueryParserError", _wrap_delete_QueryParserError, METH_O, NULL},
	 { "QueryParserError_swigregister", QueryParserError_swigregister, METH_O, NULL},
	 { "QueryParserError_swiginit", QueryParserError_swiginit, METH_VARARGS, NULL},
	 { "new_SerialisationError", _wrap_new_SerialisationError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::SerialisationError::SerialisationError(std::string_view msg_,\n"
		"int errno_) Xapian::SerialisationError::SerialisationError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_SerialisationError", _wrap_delete_SerialisationError, METH_O, NULL},
	 { "SerialisationError_swigregister", SerialisationError_swigregister, METH_O, NULL},
	 { "SerialisationError_swiginit", SerialisationError_swiginit, METH_VARARGS, NULL},
	 { "new_RangeError", _wrap_new_RangeError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::RangeError::RangeError(std::string_view msg_, int errno_)\n"
		"Xapian::RangeError::RangeError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_RangeError", _wrap_delete_RangeError, METH_O, NULL},
	 { "RangeError_swigregister", RangeError_swigregister, METH_O, NULL},
	 { "RangeError_swiginit", RangeError_swiginit, METH_VARARGS, NULL},
	 { "new_WildcardError", _wrap_new_WildcardError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::WildcardError::WildcardError(std::string_view msg_, int\n"
		"errno_) Xapian::WildcardError::WildcardError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_WildcardError", _wrap_delete_WildcardError, METH_O, NULL},
	 { "WildcardError_swigregister", WildcardError_swigregister, METH_O, NULL},
	 { "WildcardError_swiginit", WildcardError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseNotFoundError", _wrap_new_DatabaseNotFoundError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseNotFoundError::DatabaseNotFoundError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseNotFoundError", _wrap_delete_DatabaseNotFoundError, METH_O, NULL},
	 { "DatabaseNotFoundError_swigregister", DatabaseNotFoundError_swigregister, METH_O, NULL},
	 { "DatabaseNotFoundError_swiginit", DatabaseNotFoundError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseClosedError", _wrap_new_DatabaseClosedError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseClosedError::DatabaseClosedError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseClosedError", _wrap_delete_DatabaseClosedError, METH_O, NULL},
	 { "DatabaseClosedError_swigregister", DatabaseClosedError_swigregister, METH_O, NULL},
	 { "DatabaseClosedError_swiginit", DatabaseClosedError_swiginit, METH_VARARGS, NULL},
	 { "version_string", _wrap_version_string, METH_NOARGS, NULL},
	 { "major_version", _wrap_major_version, METH_NOARGS, NULL},
	 { "minor_version", _wrap_minor_version, METH_NOARGS, NULL},
	 { "revision", _wrap_revision, METH_NOARGS, NULL},
	 { "new__PositionIterator", _wrap_new__PositionIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::PositionIterator::PositionIterator() noexcept\n"
		"Xapian::PositionIterator::PositionIterator Creates an uninitialised\n"
		"iterator, which can't be used before being assigned to, but is\n"
		"sometimes syntactically convenient. \n"
		""},
	 { "delete__PositionIterator", _wrap_delete__PositionIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::PositionIterator::~PositionIterator()\n"
		"Xapian::PositionIterator::~PositionIterator\n"
		""},
	 { "_PositionIterator_skip_to", _wrap__PositionIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to term position termpos.\n"
		"\n"
		"void Xapian::PositionIterator::skip_to(Xapian::termpos termpos)\n"
		"Xapian::PositionIterator::skip_to\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"termpos:  The position to advance to. If this position isn't in the\n"
		"stream being iterated, then the iterator is moved to the next term\n"
		"position after it which is. \n"
		""},
	 { "_PositionIterator___str__", _wrap__PositionIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::PositionIterator::get_description() const\n"
		"Xapian::PositionIterator::get_description\n"
		""},
	 { "_PositionIterator___eq__", _wrap__PositionIterator___eq__, METH_VARARGS, NULL},
	 { "_PositionIterator___ne__", _wrap__PositionIterator___ne__, METH_VARARGS, NULL},
	 { "_PositionIterator_equals", _wrap__PositionIterator_equals, METH_VARARGS, NULL},
	 { "_PositionIterator_get_termpos", _wrap__PositionIterator_get_termpos, METH_O, NULL},
	 { "_PositionIterator___next__", _wrap__PositionIterator___next__, METH_O, NULL},
	 { "_PositionIterator_swigregister", _PositionIterator_swigregister, METH_O, NULL},
	 { "_PositionIterator_swiginit", _PositionIterator_swiginit, METH_VARARGS, NULL},
	 { "new__PostingIterator", _wrap_new__PostingIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::PostingIterator::PostingIterator() noexcept\n"
		"Xapian::PostingIterator::PostingIterator Creates an uninitialised\n"
		"iterator, which can't be used before being assigned to, but is\n"
		"sometimes syntactically convenient. \n"
		""},
	 { "delete__PostingIterator", _wrap_delete__PostingIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::PostingIterator::~PostingIterator()\n"
		"Xapian::PostingIterator::~PostingIterator\n"
		""},
	 { "_PostingIterator_get_wdf", _wrap__PostingIterator_get_wdf, METH_O, "\n"
		"\n"
		"\n"
		"Return the wdf for the document at the current position.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_wdf() const\n"
		"Xapian::PostingIterator::get_wdf\n"
		""},
	 { "_PostingIterator_get_doclength", _wrap__PostingIterator_get_doclength, METH_O, "\n"
		"\n"
		"\n"
		"Return the length of the document at the current position.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_doclength() const\n"
		"Xapian::PostingIterator::get_doclength\n"
		""},
	 { "_PostingIterator_get_unique_terms", _wrap__PostingIterator_get_unique_terms, METH_O, "\n"
		"\n"
		"\n"
		"Return the number of unique terms in the current document.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_unique_terms() const\n"
		"Xapian::PostingIterator::get_unique_terms\n"
		""},
	 { "_PostingIterator_get_wdfdocmax", _wrap__PostingIterator_get_wdfdocmax, METH_O, "\n"
		"\n"
		"\n"
		"Return the max_wdf in the current document.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_wdfdocmax() const\n"
		"Xapian::PostingIterator::get_wdfdocmax\n"
		""},
	 { "_PostingIterator__positionlist_begin", _wrap__PostingIterator__positionlist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Return a PositionIterator for the current document.\n"
		"\n"
		"PositionIterator Xapian::PostingIterator::positionlist_begin() const\n"
		"Xapian::PostingIterator::positionlist_begin\n"
		""},
	 { "_PostingIterator__positionlist_end", _wrap__PostingIterator__positionlist_end, METH_O, "\n"
		"\n"
		"\n"
		"Return an end PositionIterator for the current document.\n"
		"\n"
		"PositionIterator Xapian::PostingIterator::positionlist_end() const\n"
		"noexcept Xapian::PostingIterator::positionlist_end\n"
		""},
	 { "_PostingIterator_skip_to", _wrap__PostingIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to document did.\n"
		"\n"
		"void Xapian::PostingIterator::skip_to(Xapian::docid did)\n"
		"Xapian::PostingIterator::skip_to\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to advance to. If this document id isn't in the\n"
		"stream being iterated, then the iterator is moved to the next document\n"
		"id after it which is. \n"
		""},
	 { "_PostingIterator___str__", _wrap__PostingIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::PostingIterator::get_description() const\n"
		"Xapian::PostingIterator::get_description\n"
		""},
	 { "_PostingIterator___eq__", _wrap__PostingIterator___eq__, METH_VARARGS, NULL},
	 { "_PostingIterator___ne__", _wrap__PostingIterator___ne__, METH_VARARGS, NULL},
	 { "_PostingIterator_equals", _wrap__PostingIterator_equals, METH_VARARGS, NULL},
	 { "_PostingIterator_get_docid", _wrap__PostingIterator_get_docid, METH_O, NULL},
	 { "_PostingIterator___next__", _wrap__PostingIterator___next__, METH_O, NULL},
	 { "_PostingIterator_swigregister", _PostingIterator_swigregister, METH_O, NULL},
	 { "_PostingIterator_swiginit", _PostingIterator_swiginit, METH_VARARGS, NULL},
	 { "new__TermIterator", _wrap_new__TermIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::TermIterator::TermIterator() noexcept\n"
		"Xapian::TermIterator::TermIterator Creates an uninitialised iterator,\n"
		"which can't be used before being assigned to, but is sometimes\n"
		"syntactically convenient. \n"
		""},
	 { "delete__TermIterator", _wrap_delete__TermIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::TermIterator::~TermIterator()\n"
		"Xapian::TermIterator::~TermIterator\n"
		""},
	 { "_TermIterator_get_wdf", _wrap__TermIterator_get_wdf, METH_O, "\n"
		"\n"
		"\n"
		"Return the wdf for the term at the current position.\n"
		"\n"
		"Xapian::termcount Xapian::TermIterator::get_wdf() const\n"
		"Xapian::TermIterator::get_wdf\n"
		""},
	 { "_TermIterator_get_termfreq", _wrap__TermIterator_get_termfreq, METH_O, "\n"
		"\n"
		"\n"
		"Return the term frequency for the term at the current position.\n"
		"\n"
		"Xapian::doccount Xapian::TermIterator::get_termfreq() const\n"
		"Xapian::TermIterator::get_termfreq Note that for a TermIterator\n"
		"returned by calling termlist_begin() on a Document object obtained\n"
		"from a sharded database, this method will return the term frequency\n"
		"from the shard that the document is in rather than for the combined\n"
		"database. \n"
		""},
	 { "_TermIterator_positionlist_count", _wrap__TermIterator_positionlist_count, METH_O, "\n"
		"\n"
		"\n"
		"Return the length of the position list for the current position.\n"
		"\n"
		"Xapian::termcount Xapian::TermIterator::positionlist_count() const\n"
		"Xapian::TermIterator::positionlist_count\n"
		""},
	 { "_TermIterator__positionlist_begin", _wrap__TermIterator__positionlist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Return a PositionIterator for the current term.\n"
		"\n"
		"PositionIterator Xapian::TermIterator::positionlist_begin() const\n"
		"Xapian::TermIterator::positionlist_begin\n"
		""},
	 { "_TermIterator__positionlist_end", _wrap__TermIterator__positionlist_end, METH_O, "\n"
		"\n"
		"\n"
		"Return an end PositionIterator for the current term.\n"
		"\n"
		"PositionIterator Xapian::TermIterator::positionlist_end() const\n"
		"noexcept Xapian::TermIterator::positionlist_end\n"
		""},
	 { "_TermIterator_skip_to", _wrap__TermIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to term term.\n"
		"\n"
		"void Xapian::TermIterator::skip_to(std::string_view term)\n"
		"Xapian::TermIterator::skip_to If the iteration is over an unsorted\n"
		"list of terms, then this method will throw\n"
		"Xapian::InvalidOperationError.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to advance to. If this term isn't in the stream being\n"
		"iterated, then the iterator is moved to the next term after it which\n"
		"is. \n"
		""},
	 { "_TermIterator___str__", _wrap__TermIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::TermIterator::get_description() const\n"
		"Xapian::TermIterator::get_description\n"
		""},
	 { "_TermIterator___eq__", _wrap__TermIterator___eq__, METH_VARARGS, NULL},
	 { "_TermIterator___ne__", _wrap__TermIterator___ne__, METH_VARARGS, NULL},
	 { "_TermIterator_equals", _wrap__TermIterator_equals, METH_VARARGS, NULL},
	 { "_TermIterator_get_term", _wrap__TermIterator_get_term, METH_O, NULL},
	 { "_TermIterator___next__", _wrap__TermIterator___next__, METH_O, NULL},
	 { "_TermIterator_swigregister", _TermIterator_swigregister, METH_O, NULL},
	 { "_TermIterator_swiginit", _TermIterator_swiginit, METH_VARARGS, NULL},
	 { "new__ValueIterator", _wrap_new__ValueIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::ValueIterator::ValueIterator() noexcept\n"
		"Xapian::ValueIterator::ValueIterator Creates an uninitialised\n"
		"iterator, which can't be used before being assigned to, but is\n"
		"sometimes syntactically convenient. \n"
		""},
	 { "delete__ValueIterator", _wrap_delete__ValueIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::ValueIterator::~ValueIterator()\n"
		"Xapian::ValueIterator::~ValueIterator\n"
		""},
	 { "_ValueIterator_get_docid", _wrap__ValueIterator_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Return the docid at the current position.\n"
		"\n"
		"Xapian::docid Xapian::ValueIterator::get_docid() const\n"
		"Xapian::ValueIterator::get_docid If we're iterating over values of a\n"
		"document, this method will throw Xapian::InvalidOperationError. \n"
		""},
	 { "_ValueIterator_get_valueno", _wrap__ValueIterator_get_valueno, METH_O, "\n"
		"\n"
		"\n"
		"Return the value slot number for the current position.\n"
		"\n"
		"Xapian::valueno Xapian::ValueIterator::get_valueno() const\n"
		"Xapian::ValueIterator::get_valueno If the iterator is over all values\n"
		"in a slot, this returns that slot's number. If the iterator is over\n"
		"the values in a particular document, it returns the number of each\n"
		"slot in turn. \n"
		""},
	 { "_ValueIterator_skip_to", _wrap__ValueIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to document id or value slot docid_or_slot.\n"
		"\n"
		"void Xapian::ValueIterator::skip_to(Xapian::docid docid_or_slot)\n"
		"Xapian::ValueIterator::skip_to If this iterator is over values in a\n"
		"document, then this method advances the iterator to value slot\n"
		"docid_or_slot, or the first slot after it if there is no value in slot\n"
		"slot.\n"
		"\n"
		"If this iterator is over values in a particular slot, then this method\n"
		"advances the iterator to document id docid_or_slot, or the first\n"
		"document id after it if there is no value in the slot we're iterating\n"
		"over for document docid_or_slot.\n"
		"\n"
		"Note: The \"two-faced\" nature of this method is due to how C++\n"
		"overloading works. Xapian::docid and Xapian::valueno are both typedefs\n"
		"for the same unsigned integer type, so overloading can't distinguish\n"
		"them.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"docid_or_slot:  The docid/slot to advance to. \n"
		""},
	 { "_ValueIterator_check", _wrap__ValueIterator_check, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if the specified docid occurs.\n"
		"\n"
		"bool Xapian::ValueIterator::check(Xapian::docid docid)\n"
		"Xapian::ValueIterator::check The caller is required to ensure that the\n"
		"specified document id did actually exists in the database.\n"
		"\n"
		"This method acts like skip_to() if that can be done at little extra\n"
		"cost, in which case it then returns true. This is how glass databases\n"
		"behave because they store values in streams which allow for an\n"
		"efficient implementation of skip_to().\n"
		"\n"
		"Otherwise it simply checks if a particular docid is present. If it is,\n"
		"it returns true. If it isn't, it returns false, and leaves the\n"
		"position unspecified (and hence the result of calling methods which\n"
		"depend on the current position, such as get_docid(), are also\n"
		"unspecified). In this state, next() will advance to the first matching\n"
		"position after document did, and skip_to() will act as it would if the\n"
		"position was the first matching position after document did.\n"
		"\n"
		"Currently the inmemory and remote backends behave in the latter way\n"
		"because they don't support streamed values and so skip_to() must check\n"
		"each document it skips over which is significantly slower.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"docid:  The document id to check. \n"
		""},
	 { "_ValueIterator___str__", _wrap__ValueIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ValueIterator::get_description() const\n"
		"Xapian::ValueIterator::get_description\n"
		""},
	 { "_ValueIterator___eq__", _wrap__ValueIterator___eq__, METH_VARARGS, NULL},
	 { "_ValueIterator___ne__", _wrap__ValueIterator___ne__, METH_VARARGS, NULL},
	 { "_ValueIterator_equals", _wrap__ValueIterator_equals, METH_VARARGS, NULL},
	 { "_ValueIterator_get_value", _wrap__ValueIterator_get_value, METH_O, NULL},
	 { "_ValueIterator___next__", _wrap__ValueIterator___next__, METH_O, NULL},
	 { "_ValueIterator_swigregister", _ValueIterator_swigregister, METH_O, NULL},
	 { "_ValueIterator_swiginit", _ValueIterator_swiginit, METH_VARARGS, NULL},
	 { "new_Document", _wrap_new_Document, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::Document::Document() Xapian::Document::Document Creates an\n"
		"empty Document. \n"
		""},
	 { "delete_Document", _wrap_delete_Document, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Document::~Document() Xapian::Document::~Document\n"
		""},
	 { "Document_get_docid", _wrap_Document_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Get the document ID this document came from.\n"
		"\n"
		"Xapian::docid Xapian::Document::get_docid() const\n"
		"Xapian::Document::get_docid If this document didn't come from a\n"
		"database, this will be 0 (in Xapian 1.0.22/1.2.4 or later; prior to\n"
		"this the returned value was uninitialised in this case).\n"
		"\n"
		"Note that if the document came from a sharded database, this is the\n"
		"docid in the shard it came from, not the docid in the combined\n"
		"database. \n"
		""},
	 { "Document_get_data", _wrap_Document_get_data, METH_O, "\n"
		"\n"
		"\n"
		"Get the document data.\n"
		"\n"
		"std::string Xapian::Document::get_data() const\n"
		"Xapian::Document::get_data\n"
		""},
	 { "Document_set_data", _wrap_Document_set_data, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the document data.\n"
		"\n"
		"void Xapian::Document::set_data(std::string_view data)\n"
		"Xapian::Document::set_data This is an opaque blob as far as Xapian is\n"
		"concerned - it's up to you to impose whatever structure you want on\n"
		"it. If you want to store structured data, consider using something\n"
		"like protocol buffers. \n"
		""},
	 { "Document_add_term", _wrap_Document_add_term, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a term to this document.\n"
		"\n"
		"void Xapian::Document::add_term(std::string_view term,\n"
		"Xapian::termcount wdf_inc=1) Xapian::Document::add_term\n"
		""},
	 { "Document_add_boolean_term", _wrap_Document_add_boolean_term, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a boolean filter term to the document.\n"
		"\n"
		"void Xapian::Document::add_boolean_term(std::string_view term)\n"
		"Xapian::Document::add_boolean_term This method adds term to the\n"
		"document with wdf of 0 - this is generally what you want for a term\n"
		"used for boolean filtering as the wdf of such terms is ignored, and it\n"
		"doesn't make sense for them to contribute to the document's length.\n"
		"\n"
		"If the specified term already indexes this document, this method has\n"
		"no effect.\n"
		"\n"
		"It is exactly the same as add_term(term, 0) and is provided as a way\n"
		"to make a common operation more explicit.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to add.\n"
		"\n"
		"This method was added in Xapian 1.0.18. \n"
		""},
	 { "Document_remove_term", _wrap_Document_remove_term, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a term from this document.\n"
		"\n"
		"void Xapian::Document::remove_term(std::string_view term)\n"
		"Xapian::Document::remove_term\n"
		""},
	 { "Document_add_posting", _wrap_Document_add_posting, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a posting for a term.\n"
		"\n"
		"void Xapian::Document::add_posting(std::string_view term,\n"
		"Xapian::termpos term_pos, Xapian::termcount wdf_inc=1)\n"
		"Xapian::Document::add_posting\n"
		""},
	 { "Document_remove_posting", _wrap_Document_remove_posting, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove posting for a term.\n"
		"\n"
		"void Xapian::Document::remove_posting(std::string_view term,\n"
		"Xapian::termpos term_pos, Xapian::termcount wdf_dec=1)\n"
		"Xapian::Document::remove_posting The instance of the specified term at\n"
		"position term_pos will be removed, and the wdf reduced by wdf_dec (the\n"
		"wdf will not ever go below zero though - the resultant wdf is clamped\n"
		"to zero if it would).\n"
		"\n"
		"If the term doesn't occur at position term_pos then\n"
		"Xapian::InvalidArgumentError is thrown. If you want to remove a single\n"
		"position which may not be present without triggering an exception you\n"
		"can call remove_postings(term, pos, pos) instead.\n"
		"\n"
		"Since 2.0.0, if the final position is removed and the wdf becomes zero\n"
		"then the term will be removed from the document. \n"
		""},
	 { "Document_remove_postings", _wrap_Document_remove_postings, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a range of postings for a term.\n"
		"\n"
		"Xapian::termpos Xapian::Document::remove_postings(std::string_view\n"
		"term, Xapian::termpos term_pos_first, Xapian::termpos term_pos_last,\n"
		"Xapian::termcount wdf_dec=1) Xapian::Document::remove_postings Any\n"
		"instances of the term at positions >= term_pos_first and <=\n"
		"term_pos_last will be removed, and the wdf reduced by wdf_dec for each\n"
		"instance removed (the wdf will not ever go below zero though - the\n"
		"resultant wdf is clamped to zero if it would).\n"
		"\n"
		"If the term doesn't occur in the range of positions specified\n"
		"(including if term_pos_first > term_pos_last) then this method does\n"
		"nothing (unlike  remove_posting() which throws an exception if the\n"
		"specified position is not present).\n"
		"\n"
		"Since 2.0.0, if all remaining positions are removed and the wdf\n"
		"becomes zero then the term will be removed from the document. Note\n"
		"that this only happens if some positions are removed though - calling\n"
		"this method on a term which has no positions and zero wdf won't remove\n"
		"that term.\n"
		"\n"
		"The number of postings removed.\n"
		"\n"
		"Added in Xapian 1.4.8. \n"
		""},
	 { "Document_clear_terms", _wrap_Document_clear_terms, METH_O, "\n"
		"\n"
		"\n"
		"Clear all terms from the document.\n"
		"\n"
		"void Xapian::Document::clear_terms() Xapian::Document::clear_terms\n"
		""},
	 { "Document_termlist_count", _wrap_Document_termlist_count, METH_O, "\n"
		"\n"
		"\n"
		"Return the number of distinct terms in this document.\n"
		"\n"
		"Xapian::termcount Xapian::Document::termlist_count() const\n"
		"Xapian::Document::termlist_count\n"
		""},
	 { "Document__termlist_begin", _wrap_Document__termlist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Start iterating the terms in this document.\n"
		"\n"
		"TermIterator Xapian::Document::termlist_begin() const\n"
		"Xapian::Document::termlist_begin The terms are returned in ascending\n"
		"string order (by byte value).\n"
		"\n"
		"Note that if the Document object came from a sharded database then the\n"
		"TermIterator returned by this method only knows about the shard the\n"
		"document came from so calling get_termfreq() on it will give you the\n"
		"term frequency in that shard rather than in the combined database. \n"
		""},
	 { "Document__termlist_end", _wrap_Document__termlist_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to  termlist_begin().\n"
		"\n"
		"TermIterator Xapian::Document::termlist_end() const noexcept\n"
		"Xapian::Document::termlist_end\n"
		""},
	 { "Document_get_value", _wrap_Document_get_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Read a value slot in this document.\n"
		"\n"
		"std::string Xapian::Document::get_value(Xapian::valueno slot) const\n"
		"Xapian::Document::get_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The slot to read the value from\n"
		"\n"
		"The value in slot slot, or an empty string if not set. \n"
		""},
	 { "Document_add_value", _wrap_Document_add_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a value to a slot in this document.\n"
		"\n"
		"void Xapian::Document::add_value(Xapian::valueno slot,\n"
		"std::string_view value) Xapian::Document::add_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The slot to set\n"
		"\n"
		"value:  The new value \n"
		""},
	 { "Document_remove_value", _wrap_Document_remove_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove any value from the specified slot.\n"
		"\n"
		"void Xapian::Document::remove_value(Xapian::valueno slot)\n"
		"Xapian::Document::remove_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The slot to remove any value from. \n"
		""},
	 { "Document_clear_values", _wrap_Document_clear_values, METH_O, "\n"
		"\n"
		"\n"
		"Clear all value slots in this document.\n"
		"\n"
		"void Xapian::Document::clear_values() Xapian::Document::clear_values\n"
		""},
	 { "Document_values_count", _wrap_Document_values_count, METH_O, "\n"
		"\n"
		"\n"
		"Count the value slots used in this document.\n"
		"\n"
		"Xapian::valueno Xapian::Document::values_count() const\n"
		"Xapian::Document::values_count\n"
		""},
	 { "Document__values_begin", _wrap_Document__values_begin, METH_O, "\n"
		"\n"
		"\n"
		"Start iterating the values in this document.\n"
		"\n"
		"ValueIterator Xapian::Document::values_begin() const\n"
		"Xapian::Document::values_begin The values are returned in ascending\n"
		"numerical slot order. \n"
		""},
	 { "Document__values_end", _wrap_Document__values_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to  values_begin().\n"
		"\n"
		"ValueIterator Xapian::Document::values_end() const noexcept\n"
		"Xapian::Document::values_end\n"
		""},
	 { "Document_serialise", _wrap_Document_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Serialise document into a string.\n"
		"\n"
		"std::string Xapian::Document::serialise() const\n"
		"Xapian::Document::serialise The document representation may change\n"
		"between Xapian releases: even between minor versions. However, it is\n"
		"guaranteed not to change if the remote database protocol has not\n"
		"changed between releases. \n"
		""},
	 { "Document_unserialise", _wrap_Document_unserialise, METH_O, NULL},
	 { "Document___str__", _wrap_Document___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Document::get_description() const\n"
		"Xapian::Document::get_description\n"
		""},
	 { "Document_swigregister", Document_swigregister, METH_O, NULL},
	 { "Document_swiginit", Document_swiginit, METH_VARARGS, NULL},
	 { "new_Registry", _wrap_new_Registry, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::Registry::Registry() Xapian::Registry::Registry The registry\n"
		"will contain all standard subclasses of user-subclassable classes. \n"
		""},
	 { "delete_Registry", _wrap_delete_Registry, METH_O, "Xapian::Registry::~Registry() Xapian::Registry::~Registry"},
	 { "Registry_register_weighting_scheme", _wrap_Registry_register_weighting_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a weighting scheme.\n"
		"\n"
		"void Xapian::Registry::register_weighting_scheme(const Xapian::Weight\n"
		"&wt) Xapian::Registry::register_weighting_scheme\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wt:  The weighting scheme to register. \n"
		""},
	 { "Registry_get_weighting_scheme", _wrap_Registry_get_weighting_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the weighting scheme given a name.\n"
		"\n"
		"const Xapian::Weight *\n"
		"Xapian::Registry::get_weighting_scheme(std::string_view name) const\n"
		"Xapian::Registry::get_weighting_scheme\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the weighting scheme to find.\n"
		"\n"
		"An object with the requested name, or NULL if the weighting scheme\n"
		"could not be found. The returned object is owned by the registry and\n"
		"so must not be deleted by the caller. \n"
		""},
	 { "Registry_register_posting_source", _wrap_Registry_register_posting_source, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined posting source class.\n"
		"\n"
		"void Xapian::Registry::register_posting_source(const\n"
		"Xapian::PostingSource &source)\n"
		"Xapian::Registry::register_posting_source\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"source:  The posting source to register. \n"
		""},
	 { "Registry_get_posting_source", _wrap_Registry_get_posting_source, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a posting source given a name.\n"
		"\n"
		"const Xapian::PostingSource *\n"
		"Xapian::Registry::get_posting_source(std::string_view name) const\n"
		"Xapian::Registry::get_posting_source\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the posting source to find.\n"
		"\n"
		"An object with the requested name, or NULL if the posting source could\n"
		"not be found. The returned object is owned by the registry and so must\n"
		"not be deleted by the caller. \n"
		""},
	 { "Registry_register_match_spy", _wrap_Registry_register_match_spy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined match spy class.\n"
		"\n"
		"void Xapian::Registry::register_match_spy(const Xapian::MatchSpy &spy)\n"
		"Xapian::Registry::register_match_spy\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"spy:  The match spy to register. \n"
		""},
	 { "Registry_get_match_spy", _wrap_Registry_get_match_spy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a match spy given a name.\n"
		"\n"
		"const Xapian::MatchSpy *\n"
		"Xapian::Registry::get_match_spy(std::string_view name) const\n"
		"Xapian::Registry::get_match_spy\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the match spy to find.\n"
		"\n"
		"An object with the requested name, or NULL if the match spy could not\n"
		"be found. The returned object is owned by the registry and so must not\n"
		"be deleted by the caller. \n"
		""},
	 { "Registry_register_lat_long_metric", _wrap_Registry_register_lat_long_metric, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined lat-long metric class.\n"
		"\n"
		"void Xapian::Registry::register_lat_long_metric(const\n"
		"Xapian::LatLongMetric &metric)\n"
		"Xapian::Registry::register_lat_long_metric\n"
		""},
	 { "Registry_get_lat_long_metric", _wrap_Registry_get_lat_long_metric, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a lat-long metric given a name.\n"
		"\n"
		"const Xapian::LatLongMetric *\n"
		"Xapian::Registry::get_lat_long_metric(std::string_view name) const\n"
		"Xapian::Registry::get_lat_long_metric The returned metric is owned by\n"
		"the registry object.\n"
		"\n"
		"Returns NULL if the metric could not be found. \n"
		""},
	 { "Registry_register_key_maker", _wrap_Registry_register_key_maker, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined KeyMaker subclass.\n"
		"\n"
		"void Xapian::Registry::register_key_maker(Xapian::KeyMaker *keymaker)\n"
		"Xapian::Registry::register_key_maker\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"keymaker:  The KeyMaker subclass to register. The clean up of this\n"
		"object is handled via Xapian's optional reference counting. The\n"
		"simplest way to do so is to allocate it with new and call release() on\n"
		"it before passing it to this method to tell Xapian to manage its\n"
		"lifetime. The alternative approach is for the caller to ensure the\n"
		"KeyMaker object remains valid for the lifetime of the Registry object.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Registry_get_key_maker", _wrap_Registry_get_key_maker, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a KeyMaker given a name.\n"
		"\n"
		"const Xapian::KeyMaker *\n"
		"Xapian::Registry::get_key_maker(std::string_view name) const\n"
		"Xapian::Registry::get_key_maker\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the KeyMaker to find.\n"
		"\n"
		"An object with the requested name, or NULL if the KeyMaker could not\n"
		"be found. The returned object must not be deleted by the caller.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Registry_swigregister", Registry_swigregister, METH_O, NULL},
	 { "Registry_swiginit", Registry_swiginit, METH_VARARGS, NULL},
	 { "delete_Query", _wrap_delete_Query, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Query::~Query() Xapian::Query::~Query\n"
		""},
	 { "Query__get_terms_begin", _wrap_Query__get_terms_begin, METH_O, "\n"
		"\n"
		"\n"
		"Begin iterator for terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_terms_begin() const\n"
		"Xapian::Query::get_terms_begin The iterator returns terms in ascending\n"
		"query position order, and will return the same term in each unique\n"
		"position it occurs in. If you want the terms in sorted order and\n"
		"without duplicates, see get_unique_terms_begin(). \n"
		""},
	 { "Query__get_terms_end", _wrap_Query__get_terms_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator for terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_terms_end() const noexcept\n"
		"Xapian::Query::get_terms_end\n"
		""},
	 { "Query_get_unique_terms_begin", _wrap_Query_get_unique_terms_begin, METH_O, "\n"
		"\n"
		"\n"
		"Begin iterator for unique terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_unique_terms_begin() const\n"
		"Xapian::Query::get_unique_terms_begin Terms are sorted and terms with\n"
		"the same name removed from the list.\n"
		"\n"
		"If you want the terms in ascending query position order, see\n"
		"get_terms_begin(). \n"
		""},
	 { "Query_get_unique_terms_end", _wrap_Query_get_unique_terms_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator for unique terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_unique_terms_end() const\n"
		"noexcept Xapian::Query::get_unique_terms_end\n"
		""},
	 { "Query_get_length", _wrap_Query_get_length, METH_O, "\n"
		"\n"
		"\n"
		"Return the length of this query object.\n"
		"\n"
		"Xapian::termcount Xapian::Query::get_length() const noexcept\n"
		"Xapian::Query::get_length\n"
		""},
	 { "Query_empty", _wrap_Query_empty, METH_O, "\n"
		"\n"
		"\n"
		"Check if this query is Xapian::Query::MatchNothing.\n"
		"\n"
		"bool Xapian::Query::empty() const noexcept Xapian::Query::empty\n"
		""},
	 { "Query_serialise", _wrap_Query_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Serialise this object into a string.\n"
		"\n"
		"std::string Xapian::Query::serialise() const\n"
		"Xapian::Query::serialise\n"
		""},
	 { "Query_unserialise", _wrap_Query_unserialise, METH_VARARGS, NULL},
	 { "Query_get_type", _wrap_Query_get_type, METH_O, "\n"
		"\n"
		"\n"
		"Get the type of the top level of the query.\n"
		"\n"
		"op Xapian::Query::get_type() const noexcept Xapian::Query::get_type\n"
		""},
	 { "Query_get_num_subqueries", _wrap_Query_get_num_subqueries, METH_O, "\n"
		"\n"
		"\n"
		"Get the number of subqueries of the top level query.\n"
		"\n"
		"size_t Xapian::Query::get_num_subqueries() const noexcept\n"
		"Xapian::Query::get_num_subqueries\n"
		""},
	 { "Query_get_leaf_wqf", _wrap_Query_get_leaf_wqf, METH_O, "\n"
		"\n"
		"\n"
		"Get the wqf parameter of a leaf node.\n"
		"\n"
		"Xapian::termcount Xapian::Query::get_leaf_wqf() const\n"
		"Xapian::Query::get_leaf_wqf\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Query_get_leaf_pos", _wrap_Query_get_leaf_pos, METH_O, "\n"
		"\n"
		"\n"
		"Get the pos parameter of a leaf node.\n"
		"\n"
		"Xapian::termpos Xapian::Query::get_leaf_pos() const\n"
		"Xapian::Query::get_leaf_pos\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Query_get_subquery", _wrap_Query_get_subquery, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Read a top level subquery.\n"
		"\n"
		"const Query Xapian::Query::get_subquery(size_t n) const\n"
		"Xapian::Query::get_subquery\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"n:  Return the n-th subquery (starting from 0) - only valid when 0 <=\n"
		"n < get_num_subqueries(). \n"
		""},
	 { "Query___str__", _wrap_Query___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Query::get_description() const\n"
		"Xapian::Query::get_description\n"
		""},
	 { "new_Query", _wrap_new_Query, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct with just an operator.\n"
		"\n"
		"Xapian::Query::Query(Query::op op_) Xapian::Query::Query\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"op_:  The operator to use - currently only OP_INVALID is useful. \n"
		""},
	 { "Query_swigregister", Query_swigregister, METH_O, NULL},
	 { "Query_swiginit", Query_swiginit, METH_VARARGS, NULL},
	 { "new_StemImplementation", _wrap_new_StemImplementation, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::StemImplementation::StemImplementation()\n"
		"Xapian::StemImplementation::StemImplementation\n"
		""},
	 { "delete_StemImplementation", _wrap_delete_StemImplementation, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor.\n"
		"\n"
		"virtual Xapian::StemImplementation::~StemImplementation()\n"
		"Xapian::StemImplementation::~StemImplementation\n"
		""},
	 { "StemImplementation___call__", _wrap_StemImplementation___call__, METH_VARARGS, NULL},
	 { "StemImplementation_use_proper_noun_heuristic", _wrap_StemImplementation_use_proper_noun_heuristic, METH_O, "\n"
		"\n"
		"\n"
		"Should QueryParser suppress stemming for capitalised words?\n"
		"\n"
		"virtual bool Xapian::StemImplementation::use_proper_noun_heuristic()\n"
		"const Xapian::StemImplementation::use_proper_noun_heuristic See\n"
		"QueryParser::feature_flag value FLAG_NO_PROPER_NOUN_HEURISTIC for\n"
		"details.\n"
		"\n"
		"The default implementation of this method returns false.\n"
		"\n"
		"Xapian 2.0.0. \n"
		""},
	 { "StemImplementation___str__", _wrap_StemImplementation___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::StemImplementation::get_description()\n"
		"const =0 Xapian::StemImplementation::get_description\n"
		""},
	 { "disown_StemImplementation", _wrap_disown_StemImplementation, METH_O, NULL},
	 { "StemImplementation_swigregister", StemImplementation_swigregister, METH_O, NULL},
	 { "StemImplementation_swiginit", StemImplementation_swiginit, METH_VARARGS, NULL},
	 { "new_Stem", _wrap_new_Stem, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a Xapian::Stem object with a user-provided stemming\n"
		"algorithm.\n"
		"\n"
		"Xapian::Stem::Stem(StemImplementation *p) Xapian::Stem::Stem You can\n"
		"subclass Xapian::StemImplementation to implement your own stemming\n"
		"algorithm (or to wrap a third-party algorithm) and then wrap your\n"
		"implementation in a Xapian::Stem object to pass to the Xapian API.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"p:  The user-subclassed StemImplementation object. This is reference\n"
		"counted, and so will be automatically deleted by the Xapian::Stem\n"
		"wrapper when no longer required. \n"
		""},
	 { "delete_Stem", _wrap_delete_Stem, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Stem::~Stem() Xapian::Stem::~Stem\n"
		""},
	 { "Stem___call__", _wrap_Stem___call__, METH_VARARGS, NULL},
	 { "Stem_is_none", _wrap_Stem_is_none, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this is a no-op stemmer.\n"
		"\n"
		"bool Xapian::Stem::is_none() const Xapian::Stem::is_none\n"
		""},
	 { "Stem___str__", _wrap_Stem___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Stem::get_description() const\n"
		"Xapian::Stem::get_description\n"
		""},
	 { "Stem_get_available_languages", _wrap_Stem_get_available_languages, METH_NOARGS, NULL},
	 { "Stem_swigregister", Stem_swigregister, METH_O, NULL},
	 { "Stem_swiginit", Stem_swiginit, METH_VARARGS, NULL},
	 { "new_TermGenerator", _wrap_new_TermGenerator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::TermGenerator::TermGenerator()\n"
		"Xapian::TermGenerator::TermGenerator\n"
		""},
	 { "delete_TermGenerator", _wrap_delete_TermGenerator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::TermGenerator::~TermGenerator()\n"
		"Xapian::TermGenerator::~TermGenerator\n"
		""},
	 { "TermGenerator_set_stemmer", _wrap_TermGenerator_set_stemmer, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the Xapian::Stem object to be used for generating stemmed terms.\n"
		"\n"
		"void Xapian::TermGenerator::set_stemmer(const Xapian::Stem &stemmer)\n"
		"Xapian::TermGenerator::set_stemmer\n"
		""},
	 { "TermGenerator_set_stopper", _wrap_TermGenerator_set_stopper, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the Xapian::Stopper object to be used for identifying stopwords.\n"
		"\n"
		"void Xapian::TermGenerator::set_stopper(const Xapian::Stopper\n"
		"*stop=NULL) Xapian::TermGenerator::set_stopper Stemmed forms of\n"
		"stopwords aren't indexed, but unstemmed forms still are so that\n"
		"searches for phrases including stop words still work.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stop:  The Stopper object to set (default NULL, which means no\n"
		"stopwords). \n"
		""},
	 { "TermGenerator_set_document", _wrap_TermGenerator_set_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the current document.\n"
		"\n"
		"void Xapian::TermGenerator::set_document(const Xapian::Document &doc)\n"
		"Xapian::TermGenerator::set_document\n"
		""},
	 { "TermGenerator_get_document", _wrap_TermGenerator_get_document, METH_O, "\n"
		"\n"
		"\n"
		"Get the current document.\n"
		"\n"
		"const Xapian::Document & Xapian::TermGenerator::get_document() const\n"
		"Xapian::TermGenerator::get_document\n"
		""},
	 { "TermGenerator_set_database", _wrap_TermGenerator_set_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the database to index spelling data to.\n"
		"\n"
		"void Xapian::TermGenerator::set_database(const\n"
		"Xapian::WritableDatabase &db) Xapian::TermGenerator::set_database\n"
		""},
	 { "TermGenerator_set_flags", _wrap_TermGenerator_set_flags, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set flags.\n"
		"\n"
		"flags Xapian::TermGenerator::set_flags(flags toggle, flags\n"
		"mask=flags(0)) Xapian::TermGenerator::set_flags The new value of flags\n"
		"is: (flags & mask) ^ toggle\n"
		"\n"
		"To just set the flags, pass the new flags in toggle and the default\n"
		"value for mask.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"toggle:  Flags to XOR.\n"
		"\n"
		"mask:  Flags to AND with first.\n"
		"\n"
		"The old flags setting. \n"
		""},
	 { "TermGenerator_set_stemming_strategy", _wrap_TermGenerator_set_stemming_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stemming strategy.\n"
		"\n"
		"void Xapian::TermGenerator::set_stemming_strategy(stem_strategy\n"
		"strategy) Xapian::TermGenerator::set_stemming_strategy This method\n"
		"controls how the stemming algorithm is applied.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STEM_NONE: Don't\n"
		"perform any stemming - only unstemmed terms are generated.\n"
		"\n"
		"STEM_SOME: Generate both stemmed (with a \"Z\" prefix) and unstemmed\n"
		"terms. No positional information is stored for unstemmed terms. This\n"
		"is the default strategy.\n"
		"\n"
		"STEM_SOME_FULL_POS: Like STEM_SOME but positional information is\n"
		"stored for both stemmed and unstemmed terms. Added in Xapian 1.4.8.\n"
		"\n"
		"STEM_ALL: Generate only stemmed terms (but without a \"Z\" prefix).\n"
		"\n"
		"STEM_ALL_Z: Generate only stemmed terms (with a \"Z\" prefix).\n"
		"\n"
		"Added in Xapian 1.3.1. \n"
		""},
	 { "TermGenerator_set_stopper_strategy", _wrap_TermGenerator_set_stopper_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stopper strategy.\n"
		"\n"
		"void Xapian::TermGenerator::set_stopper_strategy(stop_strategy\n"
		"strategy) Xapian::TermGenerator::set_stopper_strategy The method\n"
		"controls how the stopper is used.\n"
		"\n"
		"You need to also call  set_stopper() for this to have any effect.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STOP_NONE: Don't\n"
		"use the stopper.\n"
		"\n"
		"STOP_ALL: If a word is identified as a stop word, skip it completely.\n"
		"\n"
		"STOP_STEMMED: If a word is identified as a stop word, index its\n"
		"unstemmed form but skip the stem. Unstemmed forms are indexed with\n"
		"positional information by default, so this allows searches for phrases\n"
		"containing stopwords to be supported. (This is the default mode).\n"
		"\n"
		"Added in Xapian 1.4.1. \n"
		""},
	 { "TermGenerator_set_max_word_length", _wrap_TermGenerator_set_max_word_length, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the maximum length word to index.\n"
		"\n"
		"void Xapian::TermGenerator::set_max_word_length(unsigned\n"
		"max_word_length) Xapian::TermGenerator::set_max_word_length The limit\n"
		"is on the length of a word prior to stemming and prior to adding any\n"
		"term prefix.\n"
		"\n"
		"The backends mostly impose a limit on the length of terms (often of\n"
		"about 240 bytes), but it's generally useful to have a lower limit to\n"
		"help prevent the index being bloated by useless junk terms from trying\n"
		"to indexing things like binary data, uuencoded data, ASCII art, etc.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_word_length:  The maximum length word to index, in bytes in UTF-8\n"
		"representation. Default is 64.\n"
		"\n"
		"Added in Xapian 1.3.1. \n"
		""},
	 { "TermGenerator_index_text", _wrap_TermGenerator_index_text, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Index some text.\n"
		"\n"
		"void Xapian::TermGenerator::index_text(std::string_view text,\n"
		"Xapian::termcount wdf_inc=1, std::string_view prefix={})\n"
		"Xapian::TermGenerator::index_text\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"text:  The text to index.\n"
		"\n"
		"wdf_inc:  The wdf increment (default 1).\n"
		"\n"
		"prefix:  The term prefix to use (default is no prefix). \n"
		""},
	 { "TermGenerator_index_text_without_positions", _wrap_TermGenerator_index_text_without_positions, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Index some text without positional information.\n"
		"\n"
		"void\n"
		"Xapian::TermGenerator::index_text_without_positions(std::string_view\n"
		"text, Xapian::termcount wdf_inc=1, std::string_view prefix={})\n"
		"Xapian::TermGenerator::index_text_without_positions Just like\n"
		"index_text, but no positional information is generated. This means\n"
		"that the database will be significantly smaller, but that phrase\n"
		"searching and NEAR won't be supported.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"text:  The text to index.\n"
		"\n"
		"wdf_inc:  The wdf increment (default 1).\n"
		"\n"
		"prefix:  The term prefix to use (default is no prefix). \n"
		""},
	 { "TermGenerator_increase_termpos", _wrap_TermGenerator_increase_termpos, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Increase the term position used by index_text.\n"
		"\n"
		"void Xapian::TermGenerator::increase_termpos(Xapian::termpos\n"
		"delta=100) Xapian::TermGenerator::increase_termpos This can be used\n"
		"between indexing text from different fields or other places to prevent\n"
		"phrase searches from spanning between them (e.g. between the title and\n"
		"body text, or between two chapters in a book).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"delta:  Amount to increase the term position by (default: 100). \n"
		""},
	 { "TermGenerator_get_termpos", _wrap_TermGenerator_get_termpos, METH_O, "\n"
		"\n"
		"\n"
		"Get the current term position.\n"
		"\n"
		"Xapian::termpos Xapian::TermGenerator::get_termpos() const\n"
		"Xapian::TermGenerator::get_termpos\n"
		""},
	 { "TermGenerator_set_termpos", _wrap_TermGenerator_set_termpos, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the current term position.\n"
		"\n"
		"void Xapian::TermGenerator::set_termpos(Xapian::termpos termpos)\n"
		"Xapian::TermGenerator::set_termpos\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"termpos:  The new term position to set. \n"
		""},
	 { "TermGenerator_set_termpos_limit", _wrap_TermGenerator_set_termpos_limit, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the term position limit.\n"
		"\n"
		"void Xapian::TermGenerator::set_termpos_limit(Xapian::termpos\n"
		"termpos_limit) Xapian::TermGenerator::set_termpos_limit\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"termpos_limit:  Upper bound on term positions that can be added.\n"
		"\n"
		"By default the only limit is the maximum value of the Xapian::termpos\n"
		"type.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "TermGenerator___str__", _wrap_TermGenerator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::TermGenerator::get_description() const\n"
		"Xapian::TermGenerator::get_description\n"
		""},
	 { "TermGenerator_swigregister", TermGenerator_swigregister, METH_O, NULL},
	 { "TermGenerator_swiginit", TermGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_MSet", _wrap_new_MSet, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::MSet::MSet() Xapian::MSet::MSet Creates an empty MSet, mostly\n"
		"useful as a placeholder. \n"
		""},
	 { "delete_MSet", _wrap_delete_MSet, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::MSet::~MSet() Xapian::MSet::~MSet\n"
		""},
	 { "MSet_sort_by_relevance", _wrap_MSet_sort_by_relevance, METH_O, "\n"
		"\n"
		"\n"
		"Sorts the list of documents in MSet according to their weights.\n"
		"\n"
		"void Xapian::MSet::sort_by_relevance() Xapian::MSet::sort_by_relevance\n"
		"Use after calling MSet::replace_weights.\n"
		"\n"
		"This invalidates any MSetIterator objects active on this MSet.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "MSet_convert_to_percent", _wrap_MSet_convert_to_percent, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Convert the weight of the current iterator position to a percentage.\n"
		"\n"
		"int Xapian::MSet::convert_to_percent(const MSetIterator &it) const\n"
		"Xapian::MSet::convert_to_percent If the weighting scheme gives\n"
		"everything zero weight (like Xapian::BoolWeight does) then all results\n"
		"will score 100%.\n"
		"\n"
		"Otherwise the percentage is calculated as a linear scaling of the\n"
		"relevance weight, with the scale factor determined by the matching\n"
		"document with the highest weight. This result scores 100% if it\n"
		"matches all the weighted query terms, and proportionally less if it\n"
		"only matches some.\n"
		"\n"
		"The returned percentage is an integer. If the calculated percentage\n"
		"before rounding is non-zero but less than 1% it is rounded up to 1% so\n"
		"that a result scoring 0% means it has zero weight.\n"
		"\n"
		"Similarly, percentages over 99% but less than 100% are always rounded\n"
		"down, so a result scoring 100% means it matches all weighted query\n"
		"terms.\n"
		"\n"
		"Note that these generally aren't percentages of anything meaningful\n"
		"(unless you use a custom weighting formula where they are!) but like\n"
		"the weights they are based on, higher values should indicate more\n"
		"relevant results. \n"
		""},
	 { "MSet_get_termfreq", _wrap_MSet_get_termfreq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the termfreq of a term.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_termfreq(std::string_view term)\n"
		"const Xapian::MSet::get_termfreq\n"
		"\n"
		"The number of documents which term occurs in. This considers all\n"
		"documents in the database being searched, so gives the same answer as\n"
		"db.get_termfreq(term) (but is more efficient for query terms as it\n"
		"returns a value cached during the search.)  Since 2.0.0, this method\n"
		"returns 0 if called on an MSet which is not associated with a database\n"
		"(which is consistent with Database::get_termfreq() returning 0 when\n"
		"called on a Database with no sub-databases); in earlier versions,\n"
		"Xapian::InvalidOperationError was thrown in this case. \n"
		""},
	 { "MSet_get_termweight", _wrap_MSet_get_termweight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the term weight of a term.\n"
		"\n"
		"double Xapian::MSet::get_termweight(std::string_view term) const\n"
		"Xapian::MSet::get_termweight\n"
		"\n"
		"The maximum weight that term could have contributed to a document.\n"
		"Since 2.0.0, this method returns 0.0 if called on an MSet which is not\n"
		"associated with a database, or with a term which wasn't present in the\n"
		"query (since in both cases the term contributes no weight to any\n"
		"matching documents); in earlier versions,\n"
		"Xapian::InvalidOperationError was thrown for the first case, and\n"
		"Xapian::InvalidArgumentError for the second. \n"
		""},
	 { "MSet_get_firstitem", _wrap_MSet_get_firstitem, METH_O, "\n"
		"\n"
		"\n"
		"Rank of first item in this MSet.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_firstitem() const\n"
		"Xapian::MSet::get_firstitem This is the parameter first passed to\n"
		"Xapian::Enquire::get_mset(). \n"
		""},
	 { "MSet_get_matches_lower_bound", _wrap_MSet_get_matches_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Lower bound on the total number of matching documents.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_matches_lower_bound() const\n"
		"Xapian::MSet::get_matches_lower_bound\n"
		""},
	 { "MSet_get_matches_estimated", _wrap_MSet_get_matches_estimated, METH_O, "\n"
		"\n"
		"\n"
		"Estimate of the total number of matching documents.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_matches_estimated() const\n"
		"Xapian::MSet::get_matches_estimated\n"
		""},
	 { "MSet_get_matches_upper_bound", _wrap_MSet_get_matches_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Upper bound on the total number of matching documents.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_matches_upper_bound() const\n"
		"Xapian::MSet::get_matches_upper_bound\n"
		""},
	 { "MSet_get_uncollapsed_matches_lower_bound", _wrap_MSet_get_uncollapsed_matches_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Lower bound on the total number of matching documents before\n"
		"collapsing.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_uncollapsed_matches_lower_bound()\n"
		"const Xapian::MSet::get_uncollapsed_matches_lower_bound Conceptually\n"
		"the same as get_matches_lower_bound() for the same query without any\n"
		"collapse part (though the actual value may differ). \n"
		""},
	 { "MSet_get_uncollapsed_matches_estimated", _wrap_MSet_get_uncollapsed_matches_estimated, METH_O, "\n"
		"\n"
		"\n"
		"Estimate of the total number of matching documents before collapsing.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_uncollapsed_matches_estimated()\n"
		"const Xapian::MSet::get_uncollapsed_matches_estimated Conceptually the\n"
		"same as get_matches_estimated() for the same query without any\n"
		"collapse part (though the actual value may differ). \n"
		""},
	 { "MSet_get_uncollapsed_matches_upper_bound", _wrap_MSet_get_uncollapsed_matches_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Upper bound on the total number of matching documents before\n"
		"collapsing.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_uncollapsed_matches_upper_bound()\n"
		"const Xapian::MSet::get_uncollapsed_matches_upper_bound Conceptually\n"
		"the same as get_matches_upper_bound() for the same query without any\n"
		"collapse part (though the actual value may differ). \n"
		""},
	 { "MSet_get_max_attained", _wrap_MSet_get_max_attained, METH_O, "\n"
		"\n"
		"\n"
		"The maximum weight attained by any document.\n"
		"\n"
		"double Xapian::MSet::get_max_attained() const\n"
		"Xapian::MSet::get_max_attained\n"
		""},
	 { "MSet_get_max_possible", _wrap_MSet_get_max_possible, METH_O, "\n"
		"\n"
		"\n"
		"The maximum possible weight any document could achieve.\n"
		"\n"
		"double Xapian::MSet::get_max_possible() const\n"
		"Xapian::MSet::get_max_possible\n"
		""},
	 { "MSet_snippet", _wrap_MSet_snippet, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Generate a snippet.\n"
		"\n"
		"std::string Xapian::MSet::snippet(std::string_view text, size_t\n"
		"length=500, const Xapian::Stem &stemmer=Xapian::Stem(), unsigned\n"
		"flags=SNIPPET_BACKGROUND_MODEL|SNIPPET_EXHAUSTIVE, std::string_view\n"
		"hi_start=\"<b>\", std::string_view hi_end=\"</b>\", std::string_view\n"
		"omit=\"...\") const Xapian::MSet::snippet This method selects a\n"
		"continuous run of words from text, based mainly on where the query\n"
		"matches (currently terms, exact phrases and wildcards are taken into\n"
		"account). If flag SNIPPET_BACKGROUND_MODEL is used (which it is by\n"
		"default) then the selection algorithm also considers the non-query\n"
		"terms in the text with the aim of showing a context which provides\n"
		"more useful information.\n"
		"\n"
		"The size of the text selected can be controlled by the length\n"
		"parameter, which specifies a number of bytes of text to aim to select.\n"
		"However slightly more text may be selected. Also the size of any\n"
		"escaping, highlighting or omission markers is not considered.\n"
		"\n"
		"The returned text is escaped to make it suitable for use in HTML/XML,\n"
		"and matches with the query will be highlighted using hi_start and\n"
		"hi_end.\n"
		"\n"
		"If the snippet seems to start or end mid-sentence, then omit is\n"
		"prepended or append (respectively) to indicate this.\n"
		"\n"
		"The same stemming algorithm which was used to build the query should\n"
		"be specified in stemmer.\n"
		"\n"
		"And flags contains flags controlling behaviour.\n"
		"\n"
		"Beware that in upstream releases 1.4.5 and earlier the escaping was\n"
		"sometimes incomplete; 1.4.32 and 2.1.0 fixed another case of missing\n"
		"escaping when hi_start and hi_end were both specified as empty strings\n"
		"and text was already within the requested length.\n"
		"\n"
		"Added in 1.3.5. \n"
		""},
	 { "MSet_fetch", _wrap_MSet_fetch, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Prefetch hint the whole MSet.\n"
		"\n"
		"void Xapian::MSet::fetch() const Xapian::MSet::fetch For a remote\n"
		"database, this may start a pipelined fetch of the requested documents\n"
		"from the remote server.\n"
		"\n"
		"For a disk-based database, this may send prefetch hints to the\n"
		"operating system such that the disk blocks the requested documents are\n"
		"stored in are more likely to be in the cache when we come to actually\n"
		"read them. \n"
		""},
	 { "MSet_size", _wrap_MSet_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of items in this MSet object.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::size() const Xapian::MSet::size\n"
		""},
	 { "MSet_empty", _wrap_MSet_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this MSet object is empty.\n"
		"\n"
		"bool Xapian::MSet::empty() const Xapian::MSet::empty\n"
		""},
	 { "MSet__begin", _wrap_MSet__begin, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the first item in this MSet.\n"
		"\n"
		"MSetIterator Xapian::MSet::begin() const Xapian::MSet::begin\n"
		""},
	 { "MSet__end", _wrap_MSet__end, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to just after the last item in this MSet.\n"
		"\n"
		"MSetIterator Xapian::MSet::end() const Xapian::MSet::end\n"
		""},
	 { "MSet_back", _wrap_MSet_back, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the last object in this MSet.\n"
		"\n"
		"MSetIterator Xapian::MSet::back() const Xapian::MSet::back\n"
		""},
	 { "MSet___str__", _wrap_MSet___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::MSet::get_description() const\n"
		"Xapian::MSet::get_description\n"
		""},
	 { "MSet_get_docid", _wrap_MSet_get_docid, METH_VARARGS, NULL},
	 { "MSet_get_document", _wrap_MSet_get_document, METH_VARARGS, NULL},
	 { "MSet__get_hit_internal", _wrap_MSet__get_hit_internal, METH_VARARGS, "\n"
		"Get an item from the MSet.\n"
		"\n"
		"The supplied index is relative to the start of the MSet, not the absolute rank\n"
		"of the item. \n"
		""},
	 { "MSet_get_document_percentage", _wrap_MSet_get_document_percentage, METH_VARARGS, NULL},
	 { "MSet_swigregister", MSet_swigregister, METH_O, NULL},
	 { "MSet_swiginit", MSet_swiginit, METH_VARARGS, NULL},
	 { "_MSetIterator_mset_set", _wrap__MSetIterator_mset_set, METH_VARARGS, NULL},
	 { "_MSetIterator_mset_get", _wrap__MSetIterator_mset_get, METH_O, NULL},
	 { "_MSetIterator_off_from_end_set", _wrap__MSetIterator_off_from_end_set, METH_VARARGS, NULL},
	 { "_MSetIterator_off_from_end_get", _wrap__MSetIterator_off_from_end_get, METH_O, NULL},
	 { "new__MSetIterator", _wrap_new__MSetIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Create an unpositioned MSetIterator.\n"
		"\n"
		"Xapian::MSetIterator::MSetIterator()\n"
		"Xapian::MSetIterator::MSetIterator\n"
		""},
	 { "_MSetIterator_get_rank", _wrap__MSetIterator_get_rank, METH_O, "\n"
		"\n"
		"\n"
		"Return the MSet rank for the current position.\n"
		"\n"
		"Xapian::doccount Xapian::MSetIterator::get_rank() const\n"
		"Xapian::MSetIterator::get_rank The rank of mset[0] is\n"
		"mset.get_firstitem(). \n"
		""},
	 { "_MSetIterator_get_document", _wrap__MSetIterator_get_document, METH_O, "\n"
		"\n"
		"\n"
		"Get the Document object for the current position.\n"
		"\n"
		"Xapian::Document Xapian::MSetIterator::get_document() const\n"
		"Xapian::MSetIterator::get_document\n"
		""},
	 { "_MSetIterator_get_weight", _wrap__MSetIterator_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Get the weight for the current position.\n"
		"\n"
		"double Xapian::MSetIterator::get_weight() const\n"
		"Xapian::MSetIterator::get_weight\n"
		""},
	 { "_MSetIterator_get_collapse_key", _wrap__MSetIterator_get_collapse_key, METH_O, "\n"
		"\n"
		"\n"
		"Return the collapse key for the current position.\n"
		"\n"
		"std::string Xapian::MSetIterator::get_collapse_key() const\n"
		"Xapian::MSetIterator::get_collapse_key If collapsing isn't in use, an\n"
		"empty string will be returned. \n"
		""},
	 { "_MSetIterator_get_collapse_count", _wrap__MSetIterator_get_collapse_count, METH_O, "\n"
		"\n"
		"\n"
		"Return a count of the number of collapses done onto the current key.\n"
		"\n"
		"Xapian::doccount Xapian::MSetIterator::get_collapse_count() const\n"
		"Xapian::MSetIterator::get_collapse_count This starts at 0, and is\n"
		"incremented each time an item is eliminated because its key is the\n"
		"same as that of the current item (as returned by get_collapse_key()).\n"
		"\n"
		"Note that this is NOT necessarily one less than the total number of\n"
		"matching documents with this collapse key due to various optimisations\n"
		"implemented in the matcher - for example, it can skip documents\n"
		"completely if it can prove their weight wouldn't be enough to make the\n"
		"result set.\n"
		"\n"
		"You can say is that if get_collapse_count() > 0 then there are >=\n"
		"get_collapse_count() other documents with the current collapse key.\n"
		"But if get_collapse_count() == 0 then there may or may not be other\n"
		"such documents. \n"
		""},
	 { "_MSetIterator_get_sort_key", _wrap__MSetIterator_get_sort_key, METH_O, "\n"
		"\n"
		"\n"
		"Return the sort key for the current position.\n"
		"\n"
		"std::string Xapian::MSetIterator::get_sort_key() const\n"
		"Xapian::MSetIterator::get_sort_key If sorting didn't use a key then an\n"
		"empty string will be returned.\n"
		"\n"
		"Added in Xapian 1.4.6. \n"
		""},
	 { "_MSetIterator_get_percent", _wrap__MSetIterator_get_percent, METH_O, "\n"
		"\n"
		"\n"
		"Convert the weight of the current iterator position to a percentage.\n"
		"\n"
		"int Xapian::MSetIterator::get_percent() const\n"
		"Xapian::MSetIterator::get_percent If the weighting scheme gives\n"
		"everything zero weight (like Xapian::BoolWeight does) then all results\n"
		"will score 100%.\n"
		"\n"
		"Otherwise the percentage is calculated as a linear scaling of the\n"
		"relevance weight, with the scale factor determined by the matching\n"
		"document with the highest weight. This result scores 100% if it\n"
		"matches all the weighted query terms, and proportionally less if it\n"
		"only matches some.\n"
		"\n"
		"The returned percentage is an integer. If the calculated percentage\n"
		"before rounding is non-zero but less than 1% it is rounded up to 1% so\n"
		"that a result scoring 0% means it has zero weight.\n"
		"\n"
		"Similarly, percentages over 99% but less than 100% are always rounded\n"
		"down, so a result scoring 100% means it matches all weighted query\n"
		"terms.\n"
		"\n"
		"Note that these generally aren't percentages of anything meaningful\n"
		"(unless you use a custom weighting formula where they are!) but like\n"
		"the weights they are based on, higher values should indicate more\n"
		"relevant results. \n"
		""},
	 { "_MSetIterator___str__", _wrap__MSetIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::MSetIterator::get_description() const\n"
		"Xapian::MSetIterator::get_description\n"
		""},
	 { "_MSetIterator___eq__", _wrap__MSetIterator___eq__, METH_VARARGS, NULL},
	 { "_MSetIterator___ne__", _wrap__MSetIterator___ne__, METH_VARARGS, NULL},
	 { "_MSetIterator_equals", _wrap__MSetIterator_equals, METH_VARARGS, NULL},
	 { "_MSetIterator_get_docid", _wrap__MSetIterator_get_docid, METH_O, NULL},
	 { "_MSetIterator___next__", _wrap__MSetIterator___next__, METH_O, NULL},
	 { "_MSetIterator_prev", _wrap__MSetIterator_prev, METH_O, NULL},
	 { "delete__MSetIterator", _wrap_delete__MSetIterator, METH_O, NULL},
	 { "_MSetIterator_swigregister", _MSetIterator_swigregister, METH_O, NULL},
	 { "_MSetIterator_swiginit", _MSetIterator_swiginit, METH_VARARGS, NULL},
	 { "new_ESet", _wrap_new_ESet, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::ESet::ESet() Xapian::ESet::ESet Creates an empty ESet, mostly\n"
		"useful as a placeholder. \n"
		""},
	 { "delete_ESet", _wrap_delete_ESet, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::ESet::~ESet() Xapian::ESet::~ESet\n"
		""},
	 { "ESet_size", _wrap_ESet_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of items in this ESet object.\n"
		"\n"
		"Xapian::termcount Xapian::ESet::size() const Xapian::ESet::size\n"
		""},
	 { "ESet_empty", _wrap_ESet_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this ESet object is empty.\n"
		"\n"
		"bool Xapian::ESet::empty() const Xapian::ESet::empty\n"
		""},
	 { "ESet_get_ebound", _wrap_ESet_get_ebound, METH_O, "\n"
		"\n"
		"\n"
		"Return a bound on the full size of this ESet object.\n"
		"\n"
		"Xapian::termcount Xapian::ESet::get_ebound() const\n"
		"Xapian::ESet::get_ebound This is a bound on size() if get_eset() had\n"
		"been called with maxitems set high enough that all results were\n"
		"returned. \n"
		""},
	 { "ESet__begin", _wrap_ESet__begin, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the first item in this ESet.\n"
		"\n"
		"ESetIterator Xapian::ESet::begin() const Xapian::ESet::begin\n"
		""},
	 { "ESet__end", _wrap_ESet__end, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to just after the last item in this ESet.\n"
		"\n"
		"ESetIterator Xapian::ESet::end() const Xapian::ESet::end\n"
		""},
	 { "ESet_back", _wrap_ESet_back, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the last object in this ESet.\n"
		"\n"
		"ESetIterator Xapian::ESet::back() const Xapian::ESet::back\n"
		""},
	 { "ESet___str__", _wrap_ESet___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ESet::get_description() const\n"
		"Xapian::ESet::get_description\n"
		""},
	 { "ESet_swigregister", ESet_swigregister, METH_O, NULL},
	 { "ESet_swiginit", ESet_swiginit, METH_VARARGS, NULL},
	 { "_ESetIterator_eset_set", _wrap__ESetIterator_eset_set, METH_VARARGS, NULL},
	 { "_ESetIterator_eset_get", _wrap__ESetIterator_eset_get, METH_O, NULL},
	 { "_ESetIterator_off_from_end_set", _wrap__ESetIterator_off_from_end_set, METH_VARARGS, NULL},
	 { "_ESetIterator_off_from_end_get", _wrap__ESetIterator_off_from_end_get, METH_O, NULL},
	 { "new__ESetIterator", _wrap_new__ESetIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Create an unpositioned ESetIterator.\n"
		"\n"
		"Xapian::ESetIterator::ESetIterator()\n"
		"Xapian::ESetIterator::ESetIterator\n"
		""},
	 { "_ESetIterator_get_weight", _wrap__ESetIterator_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Get the weight for the current position.\n"
		"\n"
		"double Xapian::ESetIterator::get_weight() const\n"
		"Xapian::ESetIterator::get_weight\n"
		""},
	 { "_ESetIterator___str__", _wrap__ESetIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ESetIterator::get_description() const\n"
		"Xapian::ESetIterator::get_description\n"
		""},
	 { "_ESetIterator___eq__", _wrap__ESetIterator___eq__, METH_VARARGS, NULL},
	 { "_ESetIterator___ne__", _wrap__ESetIterator___ne__, METH_VARARGS, NULL},
	 { "_ESetIterator_equals", _wrap__ESetIterator_equals, METH_VARARGS, NULL},
	 { "_ESetIterator_get_term", _wrap__ESetIterator_get_term, METH_O, NULL},
	 { "_ESetIterator___next__", _wrap__ESetIterator___next__, METH_O, NULL},
	 { "_ESetIterator_prev", _wrap__ESetIterator_prev, METH_O, NULL},
	 { "delete__ESetIterator", _wrap_delete__ESetIterator, METH_O, NULL},
	 { "_ESetIterator_swigregister", _ESetIterator_swigregister, METH_O, NULL},
	 { "_ESetIterator_swiginit", _ESetIterator_swiginit, METH_VARARGS, NULL},
	 { "__eq__", _wrap___eq__, METH_VARARGS, NULL},
	 { "__lt__", _wrap___lt__, METH_VARARGS, NULL},
	 { "__gt__", _wrap___gt__, METH_VARARGS, NULL},
	 { "__ge__", _wrap___ge__, METH_VARARGS, NULL},
	 { "__le__", _wrap___le__, METH_VARARGS, NULL},
	 { "__add__", _wrap___add__, METH_VARARGS, NULL},
	 { "new_RSet", _wrap_new_RSet, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::RSet::RSet() Xapian::RSet::RSet Creates an empty RSet. \n"
		""},
	 { "delete_RSet", _wrap_delete_RSet, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::RSet::~RSet() Xapian::RSet::~RSet\n"
		""},
	 { "RSet_size", _wrap_RSet_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of documents in this RSet object.\n"
		"\n"
		"Xapian::doccount Xapian::RSet::size() const Xapian::RSet::size\n"
		""},
	 { "RSet_empty", _wrap_RSet_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this RSet object is empty.\n"
		"\n"
		"bool Xapian::RSet::empty() const Xapian::RSet::empty\n"
		""},
	 { "RSet_add_document", _wrap_RSet_add_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Mark a document as relevant.\n"
		"\n"
		"void Xapian::RSet::add_document(const Xapian::MSetIterator &it)\n"
		"Xapian::RSet::add_document If did is already marked as relevant,\n"
		"nothing happens. \n"
		""},
	 { "RSet_remove_document", _wrap_RSet_remove_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unmark a document as relevant.\n"
		"\n"
		"void Xapian::RSet::remove_document(const Xapian::MSetIterator &it)\n"
		"Xapian::RSet::remove_document If did is not marked as relevant,\n"
		"nothing happens. \n"
		""},
	 { "RSet_contains", _wrap_RSet_contains, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if a document is marked as relevant.\n"
		"\n"
		"bool Xapian::RSet::contains(const Xapian::MSetIterator &it) const\n"
		"Xapian::RSet::contains\n"
		""},
	 { "RSet___str__", _wrap_RSet___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::RSet::get_description() const\n"
		"Xapian::RSet::get_description\n"
		""},
	 { "RSet_swigregister", RSet_swigregister, METH_O, NULL},
	 { "RSet_swiginit", RSet_swiginit, METH_VARARGS, NULL},
	 { "new_MatchDecider", _wrap_new_MatchDecider, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor, needed by subclass constructors.\n"
		"\n"
		"Xapian::MatchDecider::MatchDecider() noexcept\n"
		"Xapian::MatchDecider::MatchDecider\n"
		""},
	 { "delete_MatchDecider", _wrap_delete_MatchDecider, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::MatchDecider::~MatchDecider()\n"
		"Xapian::MatchDecider::~MatchDecider\n"
		""},
	 { "MatchDecider___call__", _wrap_MatchDecider___call__, METH_VARARGS, NULL},
	 { "disown_MatchDecider", _wrap_disown_MatchDecider, METH_O, NULL},
	 { "MatchDecider_swigregister", MatchDecider_swigregister, METH_O, NULL},
	 { "MatchDecider_swiginit", MatchDecider_swiginit, METH_VARARGS, NULL},
	 { "new_Enquire", _wrap_new_Enquire, METH_O, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::Enquire::Enquire(const Database &db) Xapian::Enquire::Enquire\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database (or databases) to query.\n"
		"\n"
		"2.0.0 If db has no subdatabases, it's handled like any other empty\n"
		"database. In earlier versions, Xapian::InvalidArgumentError was thrown\n"
		"in this case. \n"
		""},
	 { "delete_Enquire", _wrap_delete_Enquire, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Enquire::~Enquire() Xapian::Enquire::~Enquire\n"
		""},
	 { "Enquire_set_query", _wrap_Enquire_set_query, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the query.\n"
		"\n"
		"void Xapian::Enquire::set_query(const Query &query, termcount\n"
		"query_length=0) Xapian::Enquire::set_query If set_query() is not\n"
		"called before calling get_mset(), the default query used will be\n"
		"Xapian::MatchNothing.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"query:  The Xapian::Query object\n"
		"\n"
		"query_length:  The query length to use (default: query.get_length())\n"
		"\n"
		""},
	 { "Enquire_get_query", _wrap_Enquire_get_query, METH_O, "\n"
		"\n"
		"\n"
		"Get the currently set query.\n"
		"\n"
		"const Query & Xapian::Enquire::get_query() const\n"
		"Xapian::Enquire::get_query If set_query() is not called before calling\n"
		"get_query(), then the default query Xapian::MatchNothing will be\n"
		"returned. \n"
		""},
	 { "Enquire_set_weighting_scheme", _wrap_Enquire_set_weighting_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the weighting scheme to use.\n"
		"\n"
		"void Xapian::Enquire::set_weighting_scheme(const Weight &weight)\n"
		"Xapian::Enquire::set_weighting_scheme The Xapian::Weight object passed\n"
		"is cloned by calling weight.clone(), so doesn't need to remain valid\n"
		"after the call.\n"
		"\n"
		"If set_weighting_scheme() is not called before calling get_mset(), the\n"
		"default weighting scheme is Xapian::BM25Weight().\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"weight:   Xapian::Weight object \n"
		""},
	 { "Enquire_set_docid_order", _wrap_Enquire_set_docid_order, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set sort order for document IDs.\n"
		"\n"
		"void Xapian::Enquire::set_docid_order(docid_order order)\n"
		"Xapian::Enquire::set_docid_order This order only has an effect on\n"
		"documents which would otherwise have equal rank. When ordering by\n"
		"relevance without a sort key, this means documents with equal weight.\n"
		"For a boolean match with no sort key, this means all documents. And if\n"
		"a sort key is used, this means documents with the same sort key (and\n"
		"also equal weight if ordering on relevance before or after the sort\n"
		"key).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"order:  This can be:  Xapian::Enquire::ASCENDING docids sort in\n"
		"ascending order (default)\n"
		"\n"
		"Xapian::Enquire::DESCENDING docids sort in descending order\n"
		"\n"
		"Xapian::Enquire::DONT_CARE docids sort in whatever order is most\n"
		"efficient for the backend\n"
		"\n"
		"Note: If you add documents in strict date order, then a boolean search\n"
		"- i.e. set_weighting_scheme(Xapian::BoolWeight()) - with\n"
		"set_docid_order(Xapian::Enquire::DESCENDING) is an efficient way to\n"
		"perform \"sort by date, newest first\", and with\n"
		"set_docid_order(Xapian::Enquire::ASCENDING) a very efficient way to\n"
		"perform \"sort by date, oldest first\". \n"
		""},
	 { "Enquire_set_sort_by_relevance", _wrap_Enquire_set_sort_by_relevance, METH_O, "\n"
		"\n"
		"\n"
		"Set the sorting to be by relevance only.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_relevance()\n"
		"Xapian::Enquire::set_sort_by_relevance This is the default. \n"
		""},
	 { "Enquire_set_sort_by_value", _wrap_Enquire_set_sort_by_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by value only.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_value(valueno sort_key, bool\n"
		"reverse) Xapian::Enquire::set_sort_by_value Note that sorting by\n"
		"values uses a string comparison, so to use this to sort by a numeric\n"
		"value you'll need to store the numeric values in a manner which sorts\n"
		"appropriately. For example, you could use Xapian::sortable_serialise()\n"
		"(which works for floating point numbers as well as integers), or store\n"
		"numbers padded with leading zeros or spaces, or with the number of\n"
		"digits prepended.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sort_key:  value number to sort on.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_key", _wrap_Enquire_set_sort_by_key, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by key generated from values only.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_key(KeyMaker *sorter, bool reverse)\n"
		"XAPIAN_NONNULL() Xapian::Enquire::set_sort_by_key\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sorter:  The functor to use for generating keys.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_value_then_relevance", _wrap_Enquire_set_sort_by_value_then_relevance, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by value, then by relevance for documents with\n"
		"the same value.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_value_then_relevance(valueno\n"
		"sort_key, bool reverse)\n"
		"Xapian::Enquire::set_sort_by_value_then_relevance Note that sorting by\n"
		"values uses a string comparison, so to use this to sort by a numeric\n"
		"value you'll need to store the numeric values in a manner which sorts\n"
		"appropriately. For example, you could use Xapian::sortable_serialise()\n"
		"(which works for floating point numbers as well as integers), or store\n"
		"numbers padded with leading zeros or spaces, or with the number of\n"
		"digits prepended.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sort_key:  value number to sort on.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_key_then_relevance", _wrap_Enquire_set_sort_by_key_then_relevance, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by keys generated from values, then by relevance\n"
		"for documents with identical keys.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_key_then_relevance(KeyMaker *sorter,\n"
		"bool reverse) XAPIAN_NONNULL()\n"
		"Xapian::Enquire::set_sort_by_key_then_relevance\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sorter:  The functor to use for generating keys.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_relevance_then_value", _wrap_Enquire_set_sort_by_relevance_then_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by relevance then value.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_relevance_then_value(valueno\n"
		"sort_key, bool reverse)\n"
		"Xapian::Enquire::set_sort_by_relevance_then_value Note that sorting by\n"
		"values uses a string comparison, so to use this to sort by a numeric\n"
		"value you'll need to store the numeric values in a manner which sorts\n"
		"appropriately. For example, you could use Xapian::sortable_serialise()\n"
		"(which works for floating point numbers as well as integers), or store\n"
		"numbers padded with leading zeros or spaces, or with the number of\n"
		"digits prepended.\n"
		"\n"
		"Note that with the default BM25 weighting scheme parameters, non-\n"
		"identical documents will rarely have the same weight, so this setting\n"
		"will give very similar results to set_sort_by_relevance(). It becomes\n"
		"more useful with particular BM25 parameter settings (e.g.\n"
		"BM25Weight(1,0,1,0,0)) or custom weighting schemes.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sort_key:  value number to sort on.\n"
		"\n"
		"reverse:  If true, reverses the sort order of sort_key. Beware that in\n"
		"1.2.16 and earlier, the sense of this parameter was incorrectly\n"
		"inverted and inconsistent with the other set_sort_by_... methods. This\n"
		"was fixed in 1.2.17, so make that version a minimum requirement if\n"
		"this detail matters to your application. \n"
		""},
	 { "Enquire_set_sort_by_relevance_then_key", _wrap_Enquire_set_sort_by_relevance_then_key, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by relevance, then by keys generated from\n"
		"values.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_relevance_then_key(KeyMaker *sorter,\n"
		"bool reverse) XAPIAN_NONNULL()\n"
		"Xapian::Enquire::set_sort_by_relevance_then_key Note that with the\n"
		"default BM25 weighting scheme parameters, non- identical documents\n"
		"will rarely have the same weight, so this setting will give very\n"
		"similar results to set_sort_by_relevance(). It becomes more useful\n"
		"with particular BM25 parameter settings (e.g. BM25Weight(1,0,1,0,0))\n"
		"or custom weighting schemes.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sorter:  The functor to use for generating keys.\n"
		"\n"
		"reverse:  If true, reverses the sort order of the generated keys.\n"
		"Beware that in 1.2.16 and earlier, the sense of this parameter was\n"
		"incorrectly inverted and inconsistent with the other set_sort_by_...\n"
		"methods. This was fixed in 1.2.17, so make that version a minimum\n"
		"requirement if this detail matters to your application. \n"
		""},
	 { "Enquire_set_collapse_key", _wrap_Enquire_set_collapse_key, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Control collapsing of results.\n"
		"\n"
		"void Xapian::Enquire::set_collapse_key(valueno collapse_key, doccount\n"
		"collapse_max=1) Xapian::Enquire::set_collapse_key The MSet returned by\n"
		"get_mset() will have only the \"best\" (at most) collapse_max\n"
		"documents with each particular non-empty value in slot collapse_key\n"
		"(\"best\" being highest ranked - i.e. highest weight or highest\n"
		"sorting key).\n"
		"\n"
		"An example use might be to create a value for each document containing\n"
		"an MD5 hash of the document contents. Then duplicate documents from\n"
		"different sources can be eliminated at search time by collapsing with\n"
		"collapse_max = 1 (it's better to eliminate duplicates at index time,\n"
		"but this may not be always be possible - for example the search may be\n"
		"over more than one Xapian database).\n"
		"\n"
		"Another use is to group matches in a particular category (e.g. you\n"
		"might collapse a mailing list search on the Subject: so that there's\n"
		"only one result per discussion thread). In this case you can use\n"
		"get_collapse_count() to give the user some idea how many other results\n"
		"there are. And if you index the Subject: as a boolean term as well as\n"
		"putting it in a value, you can offer a link to a non-collapsed search\n"
		"restricted to that thread using a boolean filter.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"collapse_key:  value slot to collapse on (default is\n"
		"Xapian::BAD_VALUENO which means no collapsing).\n"
		"\n"
		"collapse_max:  Maximum number of documents with the same key to allow\n"
		"(default: 1). \n"
		""},
	 { "Enquire_set_cutoff", _wrap_Enquire_set_cutoff, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set lower bounds on percentage and/or weight.\n"
		"\n"
		"void Xapian::Enquire::set_cutoff(int percent_threshold, double\n"
		"weight_threshold=0) Xapian::Enquire::set_cutoff\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"percent_threshold:  Lower bound on percentage score\n"
		"\n"
		"weight_threshold:  Lower bound on weight (default: 0)\n"
		"\n"
		"No thresholds are applied by default, and if either threshold is set\n"
		"to 0, then that threshold is disabled. \n"
		""},
	 { "Enquire_add_matchspy", _wrap_Enquire_add_matchspy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a matchspy.\n"
		"\n"
		"void Xapian::Enquire::add_matchspy(MatchSpy *spy) XAPIAN_NONNULL()\n"
		"Xapian::Enquire::add_matchspy This matchspy will be called with some\n"
		"of the documents which match the query, during the match process.\n"
		"Exactly which of the matching documents are passed to it depends on\n"
		"exactly when certain optimisations occur during the match process, but\n"
		"it can be controlled to some extent by setting the checkatleast\n"
		"parameter to  get_mset().\n"
		"\n"
		"In particular, if there are enough matching documents, at least the\n"
		"number specified by checkatleast will be passed to the matchspy. This\n"
		"means that you can force the matchspy to be shown all matching\n"
		"documents by setting checkatleast to the number of documents in the\n"
		"database.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"spy:  The MatchSpy subclass to add. The caller must ensure that this\n"
		"remains valid while the Enquire object remains active, or until\n"
		"clear_matchspies() is called, or else allocate the MatchSpy object\n"
		"with new and then disown it by calling spy->release() before passing\n"
		"it in. \n"
		""},
	 { "Enquire_clear_matchspies", _wrap_Enquire_clear_matchspies, METH_O, "\n"
		"\n"
		"\n"
		"Remove all the matchspies.\n"
		"\n"
		"void Xapian::Enquire::clear_matchspies()\n"
		"Xapian::Enquire::clear_matchspies\n"
		""},
	 { "Enquire_set_time_limit", _wrap_Enquire_set_time_limit, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set a time limit for the match.\n"
		"\n"
		"void Xapian::Enquire::set_time_limit(double time_limit)\n"
		"Xapian::Enquire::set_time_limit Matches with check_at_least set high\n"
		"can take a long time in some cases. You can set a time limit on this,\n"
		"after which check_at_least will be turned off.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"time_limit:  time in seconds after which to disable check_at_least\n"
		"(default: 0.0 which means no time limit)\n"
		"\n"
		"Limitations:\n"
		"\n"
		"This feature is currently supported on platforms which support POSIX\n"
		"interval timers. Interaction with the remote backend when using\n"
		"multiple databases may have bugs. There's not currently a way to force\n"
		"the match to end after a certain time. \n"
		""},
	 { "Enquire_get_mset", _wrap_Enquire_get_mset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Run the query.\n"
		"\n"
		"MSet Xapian::Enquire::get_mset(doccount first, doccount maxitems,\n"
		"const RSet *rset, const MatchDecider *mdecider=NULL) const\n"
		"Xapian::Enquire::get_mset Run the query using the settings in this\n"
		"Enquire object and those passed as parameters to the method, and\n"
		"return a Xapian::MSet object.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"first:  Zero-based index of the first result to return (which supports\n"
		"retrieving pages of results).\n"
		"\n"
		"maxitems:  The maximum number of documents to return.\n"
		"\n"
		"rset:  Documents marked as relevant (default: no documents have been\n"
		"marked as relevant)\n"
		"\n"
		"mdecider:   Xapian::MatchDecider object - this acts as a yes/no filter\n"
		"on documents which match the query. See also Xapian::PostingSource.\n"
		"(default: no Xapian::MatchDecider) \n"
		""},
	 { "Enquire__get_matching_terms_begin", _wrap_Enquire__get_matching_terms_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Iterate query terms matching a document.\n"
		"\n"
		"TermIterator Xapian::Enquire::get_matching_terms_begin(const\n"
		"MSetIterator &it) const Xapian::Enquire::get_matching_terms_begin\n"
		"Convenience overloaded form, taking a Xapian::MSetIterator instead of\n"
		"a Xapian::docid.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"it:   MSetIterator to return matching terms for \n"
		""},
	 { "Enquire__get_matching_terms_end", _wrap_Enquire__get_matching_terms_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to  get_matching_terms_begin().\n"
		"\n"
		"TermIterator Xapian::Enquire::get_matching_terms_end(const\n"
		"MSetIterator &) const noexcept\n"
		"Xapian::Enquire::get_matching_terms_end\n"
		""},
	 { "Enquire_set_expansion_scheme", _wrap_Enquire_set_expansion_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the weighting scheme to use for expansion.\n"
		"\n"
		"void Xapian::Enquire::set_expansion_scheme(std::string_view\n"
		"eweightname, double expand_k=1.0) const\n"
		"Xapian::Enquire::set_expansion_scheme If you don't call this method,\n"
		"the default is as if you'd used:\n"
		"\n"
		"set_expansion_scheme(\"prob\");\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"eweightname:  A string in lowercase specifying the name of the scheme\n"
		"to be used. The following schemes are currently available: \"bo1\":\n"
		"Bose-Einstein 1 model from the Divergence From Randomness framework.\n"
		"\n"
		"\"prob\" : Probabilistic model (since 1.4.26).\n"
		"\n"
		"\"trad\" : Deprecated alias for \"prob\".\n"
		"\n"
		"expand_k:  Parameter k for probabilistic query expansion. A default\n"
		"value of 1.0 is used if none is specified. \n"
		""},
	 { "Enquire_get_eset", _wrap_Enquire_get_eset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Perform query expansion.\n"
		"\n"
		"ESet Xapian::Enquire::get_eset(termcount maxitems, const RSet &rset,\n"
		"const ExpandDecider *edecider) const Xapian::Enquire::get_eset Perform\n"
		"query expansion using a Xapian::RSet indicating some documents which\n"
		"are relevant (typically based on the user marking results or similar).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"maxitems:  The maximum number of terms to return.\n"
		"\n"
		"rset:  Documents marked as relevant.\n"
		"\n"
		"edecider:   Xapian::ExpandDecider object - this acts as a yes/no\n"
		"filter on terms which are being considered.\n"
		"\n"
		"Xapian::ESet object containing a list of terms with weights. \n"
		""},
	 { "Enquire___str__", _wrap_Enquire___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Enquire::get_description() const\n"
		"Xapian::Enquire::get_description\n"
		""},
	 { "Enquire_swigregister", Enquire_swigregister, METH_O, NULL},
	 { "Enquire_swiginit", Enquire_swiginit, METH_VARARGS, NULL},
	 { "new_ExpandDecider", _wrap_new_ExpandDecider, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::ExpandDecider::ExpandDecider()\n"
		"Xapian::ExpandDecider::ExpandDecider\n"
		""},
	 { "ExpandDecider___call__", _wrap_ExpandDecider___call__, METH_VARARGS, NULL},
	 { "delete_ExpandDecider", _wrap_delete_ExpandDecider, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::ExpandDecider::~ExpandDecider()\n"
		"Xapian::ExpandDecider::~ExpandDecider\n"
		""},
	 { "ExpandDecider_release", _wrap_ExpandDecider_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const ExpandDecider * Xapian::ExpandDecider::release() const\n"
		"Xapian::ExpandDecider::release You can transfer ownership of a\n"
		"dynamically allocated ExpandDecider object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_ExpandDecider", _wrap_disown_ExpandDecider, METH_O, NULL},
	 { "ExpandDecider_swigregister", ExpandDecider_swigregister, METH_O, NULL},
	 { "ExpandDecider_swiginit", ExpandDecider_swiginit, METH_VARARGS, NULL},
	 { "new_ExpandDeciderAnd", _wrap_new_ExpandDeciderAnd, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compatibility method.\n"
		"\n"
		"Xapian::ExpandDeciderAnd::ExpandDeciderAnd(const ExpandDecider\n"
		"*first_, const ExpandDecider *second_)\n"
		"Xapian::ExpandDeciderAnd::ExpandDeciderAnd\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"first_:  First ExpandDecider object to test with.\n"
		"\n"
		"second_:   ExpandDecider object to test with if first_ accepts. \n"
		""},
	 { "delete_ExpandDeciderAnd", _wrap_delete_ExpandDeciderAnd, METH_O, NULL},
	 { "ExpandDeciderAnd_swigregister", ExpandDeciderAnd_swigregister, METH_O, NULL},
	 { "ExpandDeciderAnd_swiginit", ExpandDeciderAnd_swiginit, METH_VARARGS, NULL},
	 { "new_ExpandDeciderFilterPrefix", _wrap_new_ExpandDeciderFilterPrefix, METH_O, "\n"
		"\n"
		"\n"
		"The parameter specify the prefix of terms to be retained.\n"
		"\n"
		"Xapian::ExpandDeciderFilterPrefix::ExpandDeciderFilterPrefix(const\n"
		"std::string &prefix_)\n"
		"Xapian::ExpandDeciderFilterPrefix::ExpandDeciderFilterPrefix\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix_:  restrict terms to the particular prefix_ \n"
		""},
	 { "delete_ExpandDeciderFilterPrefix", _wrap_delete_ExpandDeciderFilterPrefix, METH_O, NULL},
	 { "ExpandDeciderFilterPrefix_swigregister", ExpandDeciderFilterPrefix_swigregister, METH_O, NULL},
	 { "ExpandDeciderFilterPrefix_swiginit", ExpandDeciderFilterPrefix_swiginit, METH_VARARGS, NULL},
	 { "new_KeyMaker", _wrap_new_KeyMaker, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::KeyMaker::KeyMaker() Xapian::KeyMaker::KeyMaker\n"
		""},
	 { "KeyMaker___call__", _wrap_KeyMaker___call__, METH_VARARGS, NULL},
	 { "delete_KeyMaker", _wrap_delete_KeyMaker, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::KeyMaker::~KeyMaker() Xapian::KeyMaker::~KeyMaker\n"
		""},
	 { "KeyMaker_name", _wrap_KeyMaker_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the name of this KeyMaker.\n"
		"\n"
		"virtual std::string Xapian::KeyMaker::name() const\n"
		"Xapian::KeyMaker::name This name is used by the remote backend. It is\n"
		"passed with the serialised parameters to the remote server so that it\n"
		"knows which class to create.\n"
		"\n"
		"Return the full namespace-qualified name of your class here - if your\n"
		"class is called MyApp::FooKeyMaker, return \"MyApp::FooKeyMaker\" from\n"
		"this method.\n"
		"\n"
		"If you don't want to support the remote backend in your KeyMaker, you\n"
		"can use the default implementation which simply throws\n"
		"Xapian::UnimplementedError. \n"
		""},
	 { "KeyMaker_release", _wrap_KeyMaker_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const KeyMaker * Xapian::KeyMaker::release() const\n"
		"Xapian::KeyMaker::release You can transfer ownership of a dynamically\n"
		"allocated KeyMaker object to Xapian by calling release() and then\n"
		"passing the object to a Xapian method. Xapian will arrange to delete\n"
		"the object once it is no longer required. \n"
		""},
	 { "disown_KeyMaker", _wrap_disown_KeyMaker, METH_O, NULL},
	 { "KeyMaker_swigregister", KeyMaker_swigregister, METH_O, NULL},
	 { "KeyMaker_swiginit", KeyMaker_swiginit, METH_VARARGS, NULL},
	 { "new_MultiValueKeyMaker", _wrap_new_MultiValueKeyMaker, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a MultiValueKeyMaker from a pair of iterators.\n"
		"\n"
		"Xapian::MultiValueKeyMaker::MultiValueKeyMaker(Iterator begin,\n"
		"Iterator end) Xapian::MultiValueKeyMaker::MultiValueKeyMaker The\n"
		"iterators must be a begin/end pair returning Xapian::valueno (or a\n"
		"compatible type) when dereferenced. \n"
		""},
	 { "MultiValueKeyMaker_add_value", _wrap_MultiValueKeyMaker_add_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a value slot to the list to build a key from.\n"
		"\n"
		"void Xapian::MultiValueKeyMaker::add_value(Xapian::valueno slot, bool\n"
		"reverse=false, std::string_view defvalue={})\n"
		"Xapian::MultiValueKeyMaker::add_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to add\n"
		"\n"
		"reverse:  Adjust values from this slot to reverse their sort order\n"
		"(default: false)\n"
		"\n"
		"defvalue:  Value to use for documents which don't have a value set in\n"
		"this slot (default: empty). This can be used to make such documents\n"
		"sort after all others by passing get_value_upper_bound(slot) + \"x\"\n"
		"this is guaranteed to be greater than any value in this slot. \n"
		""},
	 { "delete_MultiValueKeyMaker", _wrap_delete_MultiValueKeyMaker, METH_O, NULL},
	 { "MultiValueKeyMaker_swigregister", MultiValueKeyMaker_swigregister, METH_O, NULL},
	 { "MultiValueKeyMaker_swiginit", MultiValueKeyMaker_swiginit, METH_VARARGS, NULL},
	 { "new_Stopper", _wrap_new_Stopper, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::Stopper::Stopper() Xapian::Stopper::Stopper\n"
		""},
	 { "Stopper___call__", _wrap_Stopper___call__, METH_VARARGS, NULL},
	 { "delete_Stopper", _wrap_delete_Stopper, METH_O, "\n"
		"\n"
		"\n"
		"Class has virtual methods, so provide a virtual destructor.\n"
		"\n"
		"virtual Xapian::Stopper::~Stopper() Xapian::Stopper::~Stopper\n"
		""},
	 { "Stopper___str__", _wrap_Stopper___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::Stopper::get_description() const\n"
		"Xapian::Stopper::get_description\n"
		""},
	 { "Stopper_release", _wrap_Stopper_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const Stopper * Xapian::Stopper::release() const\n"
		"Xapian::Stopper::release You can transfer ownership of a dynamically\n"
		"allocated Stopper object to Xapian by calling release() and then\n"
		"passing the object to a Xapian method. Xapian will arrange to delete\n"
		"the object once it is no longer required. \n"
		""},
	 { "disown_Stopper", _wrap_disown_Stopper, METH_O, NULL},
	 { "Stopper_swigregister", Stopper_swigregister, METH_O, NULL},
	 { "Stopper_swiginit", Stopper_swiginit, METH_VARARGS, NULL},
	 { "SimpleStopper_add", _wrap_SimpleStopper_add, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a single stop word.\n"
		"\n"
		"void Xapian::SimpleStopper::add(const std::string &word)\n"
		"Xapian::SimpleStopper::add\n"
		""},
	 { "new_SimpleStopper", _wrap_new_SimpleStopper, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Initialise from a pair of iterators.\n"
		"\n"
		"Xapian::SimpleStopper::SimpleStopper(Iterator begin, Iterator end)\n"
		"Xapian::SimpleStopper::SimpleStopper  Xapian includes stopword list\n"
		"files for many languages. You can initialise from a file like so:\n"
		"\n"
		"In bindings for other languages it isn't possible to pass a C++\n"
		"iterator pair, so instead this constructor is wrapped to allow passing\n"
		"a filename. \n"
		""},
	 { "delete_SimpleStopper", _wrap_delete_SimpleStopper, METH_O, NULL},
	 { "SimpleStopper_swigregister", SimpleStopper_swigregister, METH_O, NULL},
	 { "SimpleStopper_swiginit", SimpleStopper_swiginit, METH_VARARGS, NULL},
	 { "new_RangeProcessor", _wrap_new_RangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::RangeProcessor::RangeProcessor(Xapian::valueno slot_,\n"
		"std::string_view str_={}, unsigned flags_=0)\n"
		"Xapian::RangeProcessor::RangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  Which value slot to generate ranges over.\n"
		"\n"
		"str_:  A string to look for to recognise values as belonging to this\n"
		"range (as a prefix by default, or as a suffix if flags\n"
		"Xapian::RP_SUFFIX is specified).\n"
		"\n"
		"flags_:  Zero or more of the following flags, combined with bitwise-or\n"
		"(| in C++): Xapian::RP_SUFFIX - require str_ as a suffix instead of a\n"
		"prefix.\n"
		"\n"
		"Xapian::RP_REPEATED - optionally allow str_ on both ends of the range,\n"
		"or only on the non-empty end - e.g. $1..$10, ..$10, 5m..50m, or 5m...\n"
		"By default a prefix is only checked for on the start (e.g.\n"
		"date:1/1/1980..31/12/1989 or date:..31/12/1989), and a suffix only on\n"
		"the end (e.g. 2..12kg or 2..kg). \n"
		""},
	 { "delete_RangeProcessor", _wrap_delete_RangeProcessor, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::RangeProcessor::~RangeProcessor()\n"
		"Xapian::RangeProcessor::~RangeProcessor\n"
		""},
	 { "RangeProcessor_check_range", _wrap_RangeProcessor_check_range, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check prefix/suffix on range.\n"
		"\n"
		"Xapian::Query Xapian::RangeProcessor::check_range(const std::string\n"
		"&b, const std::string &e) Xapian::RangeProcessor::check_range If they\n"
		"match, remove the prefix/suffix and then call operator()() to try to\n"
		"handle the range. \n"
		""},
	 { "RangeProcessor___call__", _wrap_RangeProcessor___call__, METH_VARARGS, NULL},
	 { "RangeProcessor_release", _wrap_RangeProcessor_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const RangeProcessor * Xapian::RangeProcessor::release() const\n"
		"Xapian::RangeProcessor::release You can transfer ownership of a\n"
		"dynamically allocated RangeProcessor object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_RangeProcessor", _wrap_disown_RangeProcessor, METH_O, NULL},
	 { "RangeProcessor_swigregister", RangeProcessor_swigregister, METH_O, NULL},
	 { "RangeProcessor_swiginit", RangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_DateRangeProcessor", _wrap_new_DateRangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno slot_,\n"
		"std::string_view str_, unsigned flags_=0, int epoch_year_=1970)\n"
		"Xapian::DateRangeProcessor::DateRangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot number to query.\n"
		"\n"
		"str_:  A prefix or suffix string to look for to recognise values as\n"
		"belonging to this date range ( flags_ determines whether this is a\n"
		"prefix or suffix).\n"
		"\n"
		"flags_:  Zero or more of the following flags, combined with bitwise-\n"
		"or: Xapian::RP_SUFFIX - require str_ as a suffix instead of a prefix.\n"
		"\n"
		"Xapian::RP_REPEATED - optionally allow str_ on both ends of the range\n"
		"- e.g. $1..$10 or 5m..50m. By default a prefix is only checked for on\n"
		"the start (e.g. date:1/1/1980..31/12/1989), and a suffix only on the\n"
		"end (e.g. 2..12kg).\n"
		"\n"
		"Xapian::RP_DATE_PREFER_MDY - interpret ambiguous dates as\n"
		"month/day/year rather than day/month/year.\n"
		"\n"
		"epoch_year_:  Year to use as the epoch for dates with 2 digit years\n"
		"(default: 1970, so 1/1/69 is 2069 while 1/1/70 is 1970).\n"
		"\n"
		"The string supplied in str_ is used by operator() to decide whether\n"
		"the pair of strings supplied to it constitute a valid range. If\n"
		"prefix_ is true, the first value in a range must begin with str_ (and\n"
		"the second value may optionally begin with str_); if prefix_ is false,\n"
		"the second value in a range must end with str_ (and the first value\n"
		"may optionally end with str_).\n"
		"\n"
		"If str_ is empty then no prefix or suffix is checked for (and\n"
		"Xapian::RP_SUFFIX and Xapian::RP_REPEATED are irrelevant) - anything\n"
		"which looks like a date range will be processed. \n"
		""},
	 { "delete_DateRangeProcessor", _wrap_delete_DateRangeProcessor, METH_O, NULL},
	 { "DateRangeProcessor_swigregister", DateRangeProcessor_swigregister, METH_O, NULL},
	 { "DateRangeProcessor_swiginit", DateRangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_NumberRangeProcessor", _wrap_new_NumberRangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::NumberRangeProcessor::NumberRangeProcessor(Xapian::valueno\n"
		"slot_, std::string_view str_={}, unsigned flags_=0)\n"
		"Xapian::NumberRangeProcessor::NumberRangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot number to query.\n"
		"\n"
		"str_:  A string to look for to recognise values as belonging to this\n"
		"numeric range.\n"
		"\n"
		"flags_:  Zero or more of the following flags, combined with bitwise-\n"
		"or: Xapian::RP_SUFFIX - require str_ as a suffix instead of a prefix.\n"
		"\n"
		"Xapian::RP_REPEATED - optionally allow str_ on both ends of the range\n"
		"- e.g. $1..$10 or 5m..50m. By default a prefix is only checked for on\n"
		"the start (e.g. date:1/1/1980..31/12/1989), and a suffix only on the\n"
		"end (e.g. 2..12kg).\n"
		"\n"
		"The string supplied in str_ is used by operator() to decide whether\n"
		"the pair of strings supplied to it constitute a valid range. If\n"
		"prefix_ is true, the first value in a range must begin with str_ (and\n"
		"the second value may optionally begin with str_); if prefix_ is false,\n"
		"the second value in a range must end with str_ (and the first value\n"
		"may optionally end with str_).\n"
		"\n"
		"If str_ is empty, the setting of prefix_ is irrelevant, and no special\n"
		"strings are required at the start or end of the strings defining the\n"
		"range.\n"
		"\n"
		"The remainder of both strings defining the endpoints must be valid\n"
		"floating point numbers. (FIXME: define format recognised).\n"
		"\n"
		"For example, if str_ is \"$\" and prefix_ is true, and the range\n"
		"processor has been added to the queryparser, the queryparser will\n"
		"accept \"$10..50\" or \"$10..$50\", but not \"10..50\" or \"10..$50\"\n"
		"as valid ranges. If str_ is \"kg\" and prefix_ is false, the\n"
		"queryparser will accept \"10..50kg\" or \"10kg..50kg\", but not\n"
		"\"10..50\" or \"10kg..50\" as valid ranges. \n"
		""},
	 { "delete_NumberRangeProcessor", _wrap_delete_NumberRangeProcessor, METH_O, NULL},
	 { "NumberRangeProcessor_swigregister", NumberRangeProcessor_swigregister, METH_O, NULL},
	 { "NumberRangeProcessor_swiginit", NumberRangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_UnitRangeProcessor", _wrap_new_UnitRangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::UnitRangeProcessor::UnitRangeProcessor(Xapian::valueno slot_,\n"
		"std::string_view str_={})\n"
		"Xapian::UnitRangeProcessor::UnitRangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot number to query.\n"
		"\n"
		"str_:  A string to look for to recognise values as belonging to this\n"
		"numeric range.\n"
		"\n"
		"The string supplied in str_ is the prefix plus \":\" that defines the\n"
		"field upon which the range query is performed.\n"
		"\n"
		"For example, if str_ is \"size:\", and the range processor has been\n"
		"added to the queryparser, the queryparser will accept \"size:3K..10K\"\n"
		"as a valid range. \n"
		""},
	 { "delete_UnitRangeProcessor", _wrap_delete_UnitRangeProcessor, METH_O, NULL},
	 { "UnitRangeProcessor_swigregister", UnitRangeProcessor_swigregister, METH_O, NULL},
	 { "UnitRangeProcessor_swiginit", UnitRangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_FieldProcessor", _wrap_new_FieldProcessor, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::FieldProcessor::FieldProcessor()\n"
		"Xapian::FieldProcessor::FieldProcessor\n"
		""},
	 { "delete_FieldProcessor", _wrap_delete_FieldProcessor, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::FieldProcessor::~FieldProcessor()\n"
		"Xapian::FieldProcessor::~FieldProcessor\n"
		""},
	 { "FieldProcessor___call__", _wrap_FieldProcessor___call__, METH_VARARGS, NULL},
	 { "FieldProcessor_release", _wrap_FieldProcessor_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const FieldProcessor * Xapian::FieldProcessor::release() const\n"
		"Xapian::FieldProcessor::release You can transfer ownership of a\n"
		"dynamically allocated FieldProcessor object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_FieldProcessor", _wrap_disown_FieldProcessor, METH_O, NULL},
	 { "FieldProcessor_swigregister", FieldProcessor_swigregister, METH_O, NULL},
	 { "FieldProcessor_swiginit", FieldProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_QueryParser", _wrap_new_QueryParser, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::QueryParser::QueryParser() Xapian::QueryParser::QueryParser\n"
		""},
	 { "delete_QueryParser", _wrap_delete_QueryParser, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::QueryParser::~QueryParser()\n"
		"Xapian::QueryParser::~QueryParser\n"
		""},
	 { "QueryParser_set_stemmer", _wrap_QueryParser_set_stemmer, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stemmer.\n"
		"\n"
		"void Xapian::QueryParser::set_stemmer(const Xapian::Stem &stemmer)\n"
		"Xapian::QueryParser::set_stemmer This sets the stemming algorithm\n"
		"which will be used by the query parser. The stemming algorithm will be\n"
		"used according to the stemming strategy set by\n"
		"set_stemming_strategy(). As of 1.3.1, this defaults to STEM_SOME, but\n"
		"in earlier versions the default was STEM_NONE. If you want to work\n"
		"with older versions, you should explicitly set a stemming strategy as\n"
		"well as setting a stemmer, otherwise your stemmer won't actually be\n"
		"used.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stemmer:  The Xapian::Stem object to set. \n"
		""},
	 { "QueryParser_set_stemming_strategy", _wrap_QueryParser_set_stemming_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stemming strategy.\n"
		"\n"
		"void Xapian::QueryParser::set_stemming_strategy(stem_strategy\n"
		"strategy) Xapian::QueryParser::set_stemming_strategy This controls how\n"
		"the query parser will apply the stemming algorithm. Note that the\n"
		"stemming algorithm is only applied to words in free-text fields -\n"
		"boolean filter terms are never stemmed.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STEM_NONE: Don't\n"
		"perform any stemming. (default in Xapian <= 1.3.0)\n"
		"\n"
		"STEM_SOME: Stem all terms except for those which start with a capital\n"
		"letter, or are followed by certain characters (currently: (/@<>=*[{\"\n"
		"), or are used with operators which need positional information.\n"
		"Stemmed terms are prefixed with 'Z'. (default in Xapian >= 1.3.1)\n"
		"\n"
		"STEM_SOME_FULL_POS: Like STEM_SOME but also stems terms used with\n"
		"operators which need positional information. Added in Xapian 1.4.8.\n"
		"\n"
		"STEM_ALL: Stem all terms (note: no 'Z' prefix is added).\n"
		"\n"
		"STEM_ALL_Z: Stem all terms (note: 'Z' prefix is added). (new in Xapian\n"
		"1.2.11 and 1.3.1) \n"
		""},
	 { "QueryParser_set_stopper", _wrap_QueryParser_set_stopper, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stopper.\n"
		"\n"
		"void Xapian::QueryParser::set_stopper(const Stopper *stop=NULL)\n"
		"Xapian::QueryParser::set_stopper\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stop:  The Stopper object to set (default NULL, which means no\n"
		"stopwords). \n"
		""},
	 { "QueryParser_set_stopper_strategy", _wrap_QueryParser_set_stopper_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stopper strategy.\n"
		"\n"
		"void Xapian::QueryParser::set_stopper_strategy(stop_strategy strategy)\n"
		"Xapian::QueryParser::set_stopper_strategy This method controls how the\n"
		"stopper is used.\n"
		"\n"
		"You need to also call  set_stopper() for this to have any effect.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STOP_NONE: Don't\n"
		"use the stopper.\n"
		"\n"
		"STOP_ALL: If a word is identified as a stop word, skip it completely.\n"
		"This makes some queries less useful (e.g. \"to be or not to be that is\n"
		"the question\" would become a search for just question if the other\n"
		"words were all stopwords). If you index with STOP_ALL you should use\n"
		"it when parsing queries too.\n"
		"\n"
		"STOP_STEMMED: If a word is identified as a stop word, assume it was\n"
		"still indexed unstemmed and don't treat it as a stopword in contexts\n"
		"where we would use the unstemmed form (for example, phrase searches,\n"
		"ADJ, NEAR). (This is the default mode).\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "QueryParser_set_default_op", _wrap_QueryParser_set_default_op, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the default operator.\n"
		"\n"
		"void Xapian::QueryParser::set_default_op(Query::op default_op)\n"
		"Xapian::QueryParser::set_default_op\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"default_op:  The operator to use to combine non-filter query items\n"
		"when no explicit operator is used.\n"
		"\n"
		"So for example, 'weather forecast' is parsed as if it were 'weather OR\n"
		"forecast' by default.\n"
		"\n"
		"The most useful values for this are OP_OR (the default) and OP_AND.\n"
		"OP_NEAR, OP_PHRASE, OP_ELITE_SET, OP_SYNONYM and OP_MAX are also\n"
		"permitted. Passing other values will result in InvalidArgumentError\n"
		"being thrown. \n"
		""},
	 { "QueryParser_get_default_op", _wrap_QueryParser_get_default_op, METH_O, "\n"
		"\n"
		"\n"
		"Get the current default operator.\n"
		"\n"
		"Query::op Xapian::QueryParser::get_default_op() const\n"
		"Xapian::QueryParser::get_default_op\n"
		""},
	 { "QueryParser_set_database", _wrap_QueryParser_set_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify the database being searched.\n"
		"\n"
		"void Xapian::QueryParser::set_database(const Database &db)\n"
		"Xapian::QueryParser::set_database\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database to use for spelling correction\n"
		"(FLAG_SPELLING_CORRECTION), and synonyms (FLAG_SYNONYM,\n"
		"FLAG_AUTO_SYNONYMS, and FLAG_AUTO_MULTIWORD_SYNONYMS). \n"
		""},
	 { "QueryParser_set_max_expansion", _wrap_QueryParser_set_max_expansion, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify the maximum expansion of a wildcard and/or partial and/or\n"
		"fuzzy term.\n"
		"\n"
		"void Xapian::QueryParser::set_max_expansion(Xapian::termcount\n"
		"max_expansion, int max_type=Xapian::Query::WILDCARD_LIMIT_ERROR,\n"
		"unsigned flags=FLAG_WILDCARD|FLAG_PARTIAL|FLAG_FUZZY)\n"
		"Xapian::QueryParser::set_max_expansion Note: you must also set\n"
		"FLAG_WILDCARD and/or FLAG_PARTIAL and/or FLAG_FUZZY in the flags\n"
		"parameter to  parse_query() for this setting to have anything to\n"
		"affect.\n"
		"\n"
		"If you don't call this method, the default settings are no limit on\n"
		"wildcard and fuzzy expansion, and partial terms expanding to the most\n"
		"frequent 100 terms - i.e. as if you'd called:\n"
		"\n"
		"set_max_expansion(0); set_max_expansion(100,\n"
		"Xapian::Query::WILDCARD_LIMIT_MOST_FREQUENT,\n"
		"Xapian::QueryParser::FLAG_PARTIAL);\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_expansion:  The maximum number of terms each wildcard in the query\n"
		"can expand to, or 0 for no limit (which is the default).\n"
		"\n"
		"max_type:    Xapian::Query::WILDCARD_LIMIT_ERROR,\n"
		"Xapian::Query::WILDCARD_LIMIT_FIRST or\n"
		"Xapian::Query::WILDCARD_LIMIT_MOST_FREQUENT (default:\n"
		"Xapian::Query::WILDCARD_LIMIT_ERROR).\n"
		"\n"
		"flags:  What to set the limit for (default:\n"
		"FLAG_WILDCARD|FLAG_PARTIAL|FLAG_FUZZY, setting the limit for all\n"
		"types).\n"
		"\n"
		"1.3.3 \n"
		""},
	 { "QueryParser_set_min_wildcard_prefix", _wrap_QueryParser_set_min_wildcard_prefix, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify minimum length for fixed initial portion in wildcard patterns.\n"
		"\n"
		"void Xapian::QueryParser::set_min_wildcard_prefix(unsigned\n"
		"min_prefix_len, unsigned flags=FLAG_WILDCARD|FLAG_PARTIAL)\n"
		"Xapian::QueryParser::set_min_wildcard_prefix It can be desirable for\n"
		"performance reasons to restrict use of wildcards to patterns with a\n"
		"fixed initial portion, so this method provides a way to specify a\n"
		"minimum length. A wildcard pattern with a shorter (or no) fixed\n"
		"initial portion will result in Xapian::QueryParser being thrown. The\n"
		"default minimum length is 0.\n"
		"\n"
		"It also provides a way to specify the minimum length of a word to\n"
		"expand for partial matching (see FLAG_PARTIAL). In this case a shorter\n"
		"word at the end of the query simply result in no partial matching. The\n"
		"default minimum length for this case is 2 (since 2.0.0 - in earlier\n"
		"versions it was effectively 0).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"min_prefix_len:  Minimum length of fixed initial portion in Unicode\n"
		"characters.\n"
		"\n"
		"flags:  What to set the minimum length for (default:\n"
		"FLAG_WILDCARD|FLAG_PARTIAL, setting the limit for both wildcards and\n"
		"partial terms).\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "QueryParser_parse_query", _wrap_QueryParser_parse_query, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Parse a query.\n"
		"\n"
		"Query Xapian::QueryParser::parse_query(std::string_view query_string,\n"
		"unsigned flags=FLAG_DEFAULT, std::string_view default_prefix={})\n"
		"Xapian::QueryParser::parse_query\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"query_string:  A free-text query as entered by a user\n"
		"\n"
		"flags:  Zero or more QueryParser::feature_flag specifying what\n"
		"features the QueryParser should support. Combine multiple values with\n"
		"bitwise-or (|) (default FLAG_DEFAULT).\n"
		"\n"
		"default_prefix:  The default term prefix to use (default none). For\n"
		"example, you can pass \"A\" when parsing an \"Author\" field.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"If:  the query string can't be parsed, then Xapian::QueryParserError\n"
		"is thrown. You can get an English error message to report to the user\n"
		"by catching it and calling get_msg() on the caught exception. The\n"
		"current possible values (in case you want to translate them) are:\n"
		"\n"
		"Unknown range operation\n"
		"\n"
		"parse error\n"
		"\n"
		"Syntax: <expression> AND <expression>\n"
		"\n"
		"Syntax: <expression> AND NOT <expression>\n"
		"\n"
		"Syntax: <expression> NOT <expression>\n"
		"\n"
		"Syntax: <expression> OR <expression>\n"
		"\n"
		"Syntax: <expression> XOR <expression> \n"
		""},
	 { "QueryParser_add_prefix", _wrap_QueryParser_add_prefix, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a FieldProcessor.\n"
		"\n"
		"void Xapian::QueryParser::add_prefix(std::string_view field,\n"
		"Xapian::FieldProcessor *proc) Xapian::QueryParser::add_prefix\n"
		""},
	 { "QueryParser_add_boolean_prefix", _wrap_QueryParser_add_boolean_prefix, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a FieldProcessor for a boolean prefix.\n"
		"\n"
		"void Xapian::QueryParser::add_boolean_prefix(std::string_view field,\n"
		"Xapian::FieldProcessor *proc, bool exclusive)\n"
		"Xapian::QueryParser::add_boolean_prefix This is an older version of\n"
		"this method - use the version with the grouping parameter in\n"
		"preference to this one. \n"
		""},
	 { "QueryParser__stoplist_begin", _wrap_QueryParser__stoplist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Begin iterator over terms omitted from the query as stopwords.\n"
		"\n"
		"TermIterator Xapian::QueryParser::stoplist_begin() const\n"
		"Xapian::QueryParser::stoplist_begin\n"
		""},
	 { "QueryParser__stoplist_end", _wrap_QueryParser__stoplist_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator over terms omitted from the query as stopwords.\n"
		"\n"
		"TermIterator Xapian::QueryParser::stoplist_end() const noexcept\n"
		"Xapian::QueryParser::stoplist_end\n"
		""},
	 { "QueryParser__unstem_begin", _wrap_QueryParser__unstem_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Begin iterator over unstemmed forms of the given stemmed query term.\n"
		"\n"
		"TermIterator Xapian::QueryParser::unstem_begin(std::string_view term)\n"
		"const Xapian::QueryParser::unstem_begin\n"
		""},
	 { "QueryParser__unstem_end", _wrap_QueryParser__unstem_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator over unstemmed forms of the given stemmed query term.\n"
		"\n"
		"TermIterator Xapian::QueryParser::unstem_end(std::string_view) const\n"
		"noexcept Xapian::QueryParser::unstem_end\n"
		""},
	 { "QueryParser_add_rangeprocessor", _wrap_QueryParser_add_rangeprocessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a RangeProcessor.\n"
		"\n"
		"void Xapian::QueryParser::add_rangeprocessor(Xapian::RangeProcessor\n"
		"*range_proc, const std::string *grouping=NULL)\n"
		"Xapian::QueryParser::add_rangeprocessor\n"
		""},
	 { "QueryParser_get_corrected_query_string", _wrap_QueryParser_get_corrected_query_string, METH_O, "\n"
		"\n"
		"\n"
		"Get the spelling-corrected query string.\n"
		"\n"
		"std::string Xapian::QueryParser::get_corrected_query_string() const\n"
		"Xapian::QueryParser::get_corrected_query_string This will only be set\n"
		"if FLAG_SPELLING_CORRECTION is specified when\n"
		"QueryParser::parse_query() was last called.\n"
		"\n"
		"If there were no corrections, an empty string is returned. \n"
		""},
	 { "QueryParser___str__", _wrap_QueryParser___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::QueryParser::get_description() const\n"
		"Xapian::QueryParser::get_description\n"
		""},
	 { "QueryParser_swigregister", QueryParser_swigregister, METH_O, NULL},
	 { "QueryParser_swiginit", QueryParser_swiginit, METH_VARARGS, NULL},
	 { "sortable_serialise", _wrap_sortable_serialise, METH_O, NULL},
	 { "sortable_unserialise", _wrap_sortable_unserialise, METH_O, NULL},
	 { "new_ValueSetMatchDecider", _wrap_new_ValueSetMatchDecider, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a ValueSetMatchDecider.\n"
		"\n"
		"Xapian::ValueSetMatchDecider::ValueSetMatchDecider(Xapian::valueno\n"
		"slot, bool inclusive_)\n"
		"Xapian::ValueSetMatchDecider::ValueSetMatchDecider\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot number to look in.\n"
		"\n"
		"inclusive_:  If true, match decider accepts documents which have a\n"
		"value in the specified slot which is a member of the test set; if\n"
		"false, match decider accepts documents which do not have a value in\n"
		"the specified slot. \n"
		""},
	 { "ValueSetMatchDecider_add_value", _wrap_ValueSetMatchDecider_add_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a value to the test set.\n"
		"\n"
		"void Xapian::ValueSetMatchDecider::add_value(const std::string &value)\n"
		"Xapian::ValueSetMatchDecider::add_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"value:  The value to add to the test set. \n"
		""},
	 { "ValueSetMatchDecider_remove_value", _wrap_ValueSetMatchDecider_remove_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a value from the test set.\n"
		"\n"
		"void Xapian::ValueSetMatchDecider::remove_value(const std::string\n"
		"&value) Xapian::ValueSetMatchDecider::remove_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"value:  The value to remove from the test set. \n"
		""},
	 { "delete_ValueSetMatchDecider", _wrap_delete_ValueSetMatchDecider, METH_O, NULL},
	 { "ValueSetMatchDecider_swigregister", ValueSetMatchDecider_swigregister, METH_O, NULL},
	 { "ValueSetMatchDecider_swiginit", ValueSetMatchDecider_swiginit, METH_VARARGS, NULL},
	 { "delete_Weight", _wrap_delete_Weight, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::Weight::~Weight() Xapian::Weight::~Weight\n"
		""},
	 { "Weight_name", _wrap_Weight_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the name of this weighting scheme, e.g.\n"
		"\n"
		"virtual std::string Xapian::Weight::name() const Xapian::Weight::name\n"
		"\"bm25+\".\n"
		"\n"
		"This is the name that the weighting scheme gets registered under when\n"
		"passed to Xapian:Registry::register_weighting_scheme().\n"
		"\n"
		"As a result:\n"
		"\n"
		"this is the name that needs to be used in Weight::create() to create a\n"
		"Weight object from a human-readable string description.\n"
		"\n"
		"it is also used by the remote backend where it is sent (along with the\n"
		"serialised parameters) to the remote server so that it knows which\n"
		"class to create.\n"
		"\n"
		"For 1.4.x and earlier we recommended returning the full namespace-\n"
		"qualified name of your class here, but now we recommend returning a\n"
		"just the name in lower case, e.g. \"foo\" instead of \"FooWeight\",\n"
		"\"bm25+\" instead of \"Xapian::BM25PlusWeight\".\n"
		"\n"
		"If you don't want to support creation via Weight::create() or the\n"
		"remote backend, you can use the default implementation which simply\n"
		"returns an empty string. \n"
		""},
	 { "Weight_get_sumpart", _wrap_Weight_get_sumpart, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the weight contribution for this object's term to a\n"
		"document.\n"
		"\n"
		"virtual double Xapian::Weight::get_sumpart(Xapian::termcount wdf,\n"
		"Xapian::termcount doclen, Xapian::termcount uniqterms,\n"
		"Xapian::termcount wdfdocmax) const =0 Xapian::Weight::get_sumpart The\n"
		"parameters give information about the document which may be used in\n"
		"the calculations:\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wdf:  The within document frequency of the term in the document. You\n"
		"need to call need_stat(WDF) if you use this value.\n"
		"\n"
		"doclen:  The document's length (unnormalised). You need to call\n"
		"need_stat(DOC_LENGTH) if you use this value.\n"
		"\n"
		"uniqterms:  Number of unique terms in the document. You need to call\n"
		"need_stat(UNIQUE_TERMS) if you use this value.\n"
		"\n"
		"wdfdocmax:  Maximum wdf value in the document. You need to call\n"
		"need_stat(WDF_DOC_MAX) if you use this value.\n"
		"\n"
		"You can rely of wdf <= doclen if you call both need_stat(WDF) and\n"
		"need_stat(DOC_LENGTH) - this is trivially true for terms, but Xapian\n"
		"also ensure it's true for OP_SYNONYM, where the wdf is approximated.\n"
		"\n"
		"The wdfdocmax parameter was added in Xapian 2.0.0. \n"
		""},
	 { "Weight_get_maxpart", _wrap_Weight_get_maxpart, METH_O, "\n"
		"\n"
		"\n"
		"Return an upper bound on what get_sumpart() can return for any\n"
		"document.\n"
		"\n"
		"virtual double Xapian::Weight::get_maxpart() const =0\n"
		"Xapian::Weight::get_maxpart This information is used by the matcher to\n"
		"perform various optimisations, so strive to make the bound as tight as\n"
		"possible. \n"
		""},
	 { "Weight_get_sumextra", _wrap_Weight_get_sumextra, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the term-independent weight component for a document.\n"
		"\n"
		"virtual double Xapian::Weight::get_sumextra(Xapian::termcount doclen,\n"
		"Xapian::termcount uniqterms, Xapian::termcount wdfdocmax) const\n"
		"Xapian::Weight::get_sumextra The default implementation always returns\n"
		"0 (in Xapian < 2.0.0 this was a pure virtual method).\n"
		"\n"
		"The parameter gives information about the document which may be used\n"
		"in the calculations:\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"doclen:  The document's length (unnormalised). You need to call\n"
		"need_stat(DOC_LENGTH) if you use this value.\n"
		"\n"
		"uniqterms:  Number of unique terms in the document. You need to call\n"
		"need_stat(UNIQUE_TERMS) if you use this value.\n"
		"\n"
		"wdfdocmax:  Maximum wdf value in the document. You need to call\n"
		"need_stat(WDF_DOC_MAX) if you use this value.\n"
		"\n"
		"The wdfdocmax parameter was added in Xapian 2.0.0. \n"
		""},
	 { "Weight_get_maxextra", _wrap_Weight_get_maxextra, METH_O, "\n"
		"\n"
		"\n"
		"Return an upper bound on what get_sumextra() can return for any\n"
		"document.\n"
		"\n"
		"virtual double Xapian::Weight::get_maxextra() const\n"
		"Xapian::Weight::get_maxextra The default implementation always returns\n"
		"0 (in Xapian < 2.0.0 this was a pure virtual method).\n"
		"\n"
		"This information is used by the matcher to perform various\n"
		"optimisations, so strive to make the bound as tight as possible. \n"
		""},
	 { "Weight_create", _wrap_Weight_create, METH_VARARGS, NULL},
	 { "Weight_create_from_parameters", _wrap_Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"virtual Weight * Xapian::Weight::create_from_parameters(const char\n"
		"*params) const Xapian::Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "Weight_swigregister", Weight_swigregister, METH_O, NULL},
	 { "new_BoolWeight", _wrap_new_BoolWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a BoolWeight.\n"
		"\n"
		"Xapian::BoolWeight::BoolWeight() Xapian::BoolWeight::BoolWeight\n"
		""},
	 { "BoolWeight_create_from_parameters", _wrap_BoolWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BoolWeight * Xapian::BoolWeight::create_from_parameters(const char\n"
		"*params) const Xapian::BoolWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BoolWeight", _wrap_delete_BoolWeight, METH_O, NULL},
	 { "BoolWeight_swigregister", BoolWeight_swigregister, METH_O, NULL},
	 { "BoolWeight_swiginit", BoolWeight_swiginit, METH_VARARGS, NULL},
	 { "new_TfIdfWeight", _wrap_new_TfIdfWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a TfIdfWeight using the default normalizations (\"ntn\").\n"
		"\n"
		"Xapian::TfIdfWeight::TfIdfWeight() Xapian::TfIdfWeight::TfIdfWeight\n"
		""},
	 { "TfIdfWeight_create_from_parameters", _wrap_TfIdfWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"TfIdfWeight * Xapian::TfIdfWeight::create_from_parameters(const char\n"
		"*params) const Xapian::TfIdfWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_TfIdfWeight", _wrap_delete_TfIdfWeight, METH_O, NULL},
	 { "TfIdfWeight_swigregister", TfIdfWeight_swigregister, METH_O, NULL},
	 { "TfIdfWeight_swiginit", TfIdfWeight_swiginit, METH_VARARGS, NULL},
	 { "new_BM25Weight", _wrap_new_BM25Weight, METH_VARARGS, "Xapian::BM25Weight::BM25Weight() Xapian::BM25Weight::BM25Weight"},
	 { "BM25Weight_create_from_parameters", _wrap_BM25Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BM25Weight * Xapian::BM25Weight::create_from_parameters(const char\n"
		"*params) const Xapian::BM25Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BM25Weight", _wrap_delete_BM25Weight, METH_O, NULL},
	 { "BM25Weight_swigregister", BM25Weight_swigregister, METH_O, NULL},
	 { "BM25Weight_swiginit", BM25Weight_swiginit, METH_VARARGS, NULL},
	 { "new_BM25PlusWeight", _wrap_new_BM25PlusWeight, METH_VARARGS, "\n"
		"Xapian::BM25PlusWeight::BM25PlusWeight()\n"
		"Xapian::BM25PlusWeight::BM25PlusWeight\n"
		""},
	 { "BM25PlusWeight_create_from_parameters", _wrap_BM25PlusWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BM25PlusWeight * Xapian::BM25PlusWeight::create_from_parameters(const\n"
		"char *params) const Xapian::BM25PlusWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BM25PlusWeight", _wrap_delete_BM25PlusWeight, METH_O, NULL},
	 { "BM25PlusWeight_swigregister", BM25PlusWeight_swigregister, METH_O, NULL},
	 { "BM25PlusWeight_swiginit", BM25PlusWeight_swiginit, METH_VARARGS, NULL},
	 { "new_TradWeight", _wrap_new_TradWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a TradWeight.\n"
		"\n"
		"Xapian::TradWeight::TradWeight(double k=1.0)\n"
		"Xapian::TradWeight::TradWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"k:  A non-negative parameter controlling how influential within-\n"
		"document- frequency (wdf) and document length are. k=0 means that wdf\n"
		"and document length don't affect the weights. The larger k is, the\n"
		"more they do. (default 1) \n"
		""},
	 { "delete_TradWeight", _wrap_delete_TradWeight, METH_O, NULL},
	 { "TradWeight_swigregister", TradWeight_swigregister, METH_O, NULL},
	 { "TradWeight_swiginit", TradWeight_swiginit, METH_VARARGS, NULL},
	 { "new_InL2Weight", _wrap_new_InL2Weight, METH_VARARGS, "Xapian::InL2Weight::InL2Weight() Xapian::InL2Weight::InL2Weight"},
	 { "InL2Weight_create_from_parameters", _wrap_InL2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"InL2Weight * Xapian::InL2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::InL2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_InL2Weight", _wrap_delete_InL2Weight, METH_O, NULL},
	 { "InL2Weight_swigregister", InL2Weight_swigregister, METH_O, NULL},
	 { "InL2Weight_swiginit", InL2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_IfB2Weight", _wrap_new_IfB2Weight, METH_VARARGS, "Xapian::IfB2Weight::IfB2Weight() Xapian::IfB2Weight::IfB2Weight"},
	 { "IfB2Weight_create_from_parameters", _wrap_IfB2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"IfB2Weight * Xapian::IfB2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::IfB2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_IfB2Weight", _wrap_delete_IfB2Weight, METH_O, NULL},
	 { "IfB2Weight_swigregister", IfB2Weight_swigregister, METH_O, NULL},
	 { "IfB2Weight_swiginit", IfB2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_IneB2Weight", _wrap_new_IneB2Weight, METH_VARARGS, "Xapian::IneB2Weight::IneB2Weight() Xapian::IneB2Weight::IneB2Weight"},
	 { "IneB2Weight_create_from_parameters", _wrap_IneB2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"IneB2Weight * Xapian::IneB2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::IneB2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_IneB2Weight", _wrap_delete_IneB2Weight, METH_O, NULL},
	 { "IneB2Weight_swigregister", IneB2Weight_swigregister, METH_O, NULL},
	 { "IneB2Weight_swiginit", IneB2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_BB2Weight", _wrap_new_BB2Weight, METH_VARARGS, "Xapian::BB2Weight::BB2Weight() Xapian::BB2Weight::BB2Weight"},
	 { "BB2Weight_create_from_parameters", _wrap_BB2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BB2Weight * Xapian::BB2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::BB2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BB2Weight", _wrap_delete_BB2Weight, METH_O, NULL},
	 { "BB2Weight_swigregister", BB2Weight_swigregister, METH_O, NULL},
	 { "BB2Weight_swiginit", BB2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_DLHWeight", _wrap_new_DLHWeight, METH_NOARGS, "Xapian::DLHWeight::DLHWeight() Xapian::DLHWeight::DLHWeight"},
	 { "DLHWeight_create_from_parameters", _wrap_DLHWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"DLHWeight * Xapian::DLHWeight::create_from_parameters(const char\n"
		"*params) const Xapian::DLHWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_DLHWeight", _wrap_delete_DLHWeight, METH_O, NULL},
	 { "DLHWeight_swigregister", DLHWeight_swigregister, METH_O, NULL},
	 { "DLHWeight_swiginit", DLHWeight_swiginit, METH_VARARGS, NULL},
	 { "new_PL2Weight", _wrap_new_PL2Weight, METH_VARARGS, "Xapian::PL2Weight::PL2Weight() Xapian::PL2Weight::PL2Weight"},
	 { "PL2Weight_create_from_parameters", _wrap_PL2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"PL2Weight * Xapian::PL2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::PL2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_PL2Weight", _wrap_delete_PL2Weight, METH_O, NULL},
	 { "PL2Weight_swigregister", PL2Weight_swigregister, METH_O, NULL},
	 { "PL2Weight_swiginit", PL2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_PL2PlusWeight", _wrap_new_PL2PlusWeight, METH_VARARGS, "\n"
		"Xapian::PL2PlusWeight::PL2PlusWeight()\n"
		"Xapian::PL2PlusWeight::PL2PlusWeight\n"
		""},
	 { "PL2PlusWeight_create_from_parameters", _wrap_PL2PlusWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"PL2PlusWeight * Xapian::PL2PlusWeight::create_from_parameters(const\n"
		"char *params) const Xapian::PL2PlusWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_PL2PlusWeight", _wrap_delete_PL2PlusWeight, METH_O, NULL},
	 { "PL2PlusWeight_swigregister", PL2PlusWeight_swigregister, METH_O, NULL},
	 { "PL2PlusWeight_swiginit", PL2PlusWeight_swiginit, METH_VARARGS, NULL},
	 { "new_DPHWeight", _wrap_new_DPHWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a DPHWeight.\n"
		"\n"
		"Xapian::DPHWeight::DPHWeight() Xapian::DPHWeight::DPHWeight\n"
		""},
	 { "DPHWeight_create_from_parameters", _wrap_DPHWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"DPHWeight * Xapian::DPHWeight::create_from_parameters(const char\n"
		"*params) const Xapian::DPHWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_DPHWeight", _wrap_delete_DPHWeight, METH_O, NULL},
	 { "DPHWeight_swigregister", DPHWeight_swigregister, METH_O, NULL},
	 { "DPHWeight_swiginit", DPHWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LMJMWeight", _wrap_new_LMJMWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LMJMWeight.\n"
		"\n"
		"Xapian::LMJMWeight::LMJMWeight(double lambda=0.0)\n"
		"Xapian::LMJMWeight::LMJMWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"lambda:  A parameter strictly between 0 and 1 which linearly\n"
		"interpolates between the maximum likelihood model (the limit as λ→0)\n"
		"and the collection model (the limit as λ→1).\n"
		"\n"
		"Values of λ around 0.1 are apparently optimal for short queries and\n"
		"around 0.7 for long queries. If lambda is out of range (i.e. <= 0 or\n"
		">= 1) then the λ value used is chosen dynamically based on the query\n"
		"length using the formula:\n"
		"\n"
		"(query_length - 1) / 10.0\n"
		"\n"
		"The result is clamped to 0.1 for query_length <= 2, and to 0.7 for\n"
		"query_length >= 8. \n"
		""},
	 { "LMJMWeight_create_from_parameters", _wrap_LMJMWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LMJMWeight * Xapian::LMJMWeight::create_from_parameters(const char\n"
		"*params) const Xapian::LMJMWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LMJMWeight", _wrap_delete_LMJMWeight, METH_O, NULL},
	 { "LMJMWeight_swigregister", LMJMWeight_swigregister, METH_O, NULL},
	 { "LMJMWeight_swiginit", LMJMWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LMDirichletWeight", _wrap_new_LMDirichletWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LMDirichletWeight.\n"
		"\n"
		"Xapian::LMDirichletWeight::LMDirichletWeight(double mu=2000.0, double\n"
		"delta=0.05) Xapian::LMDirichletWeight::LMDirichletWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"mu:  A parameter which is > 0. Default: 2000\n"
		"\n"
		"delta:  A parameter which is >= 0, which is \"a pseudo [wdf] value to\n"
		"control the scale of the [wdf] lower bound\". If this parameter is >\n"
		"0, then the smoothing is Dir+; if it's zero, it's Dirichlet. Default:\n"
		"0.05 \n"
		""},
	 { "LMDirichletWeight_create_from_parameters", _wrap_LMDirichletWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LMDirichletWeight *\n"
		"Xapian::LMDirichletWeight::create_from_parameters(const char *params)\n"
		"const Xapian::LMDirichletWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LMDirichletWeight", _wrap_delete_LMDirichletWeight, METH_O, NULL},
	 { "LMDirichletWeight_swigregister", LMDirichletWeight_swigregister, METH_O, NULL},
	 { "LMDirichletWeight_swiginit", LMDirichletWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LMAbsDiscountWeight", _wrap_new_LMAbsDiscountWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LMAbsDiscountWeight.\n"
		"\n"
		"Xapian::LMAbsDiscountWeight::LMAbsDiscountWeight(double delta=0.7)\n"
		"Xapian::LMAbsDiscountWeight::LMAbsDiscountWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"delta:  A parameter between 0 and 1. Default: 0.7 \n"
		""},
	 { "LMAbsDiscountWeight_create_from_parameters", _wrap_LMAbsDiscountWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LMAbsDiscountWeight *\n"
		"Xapian::LMAbsDiscountWeight::create_from_parameters(const char\n"
		"*params) const Xapian::LMAbsDiscountWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LMAbsDiscountWeight", _wrap_delete_LMAbsDiscountWeight, METH_O, NULL},
	 { "LMAbsDiscountWeight_swigregister", LMAbsDiscountWeight_swigregister, METH_O, NULL},
	 { "LMAbsDiscountWeight_swiginit", LMAbsDiscountWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LM2StageWeight", _wrap_new_LM2StageWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LM2StageWeight.\n"
		"\n"
		"Xapian::LM2StageWeight::LM2StageWeight(double lambda=0.7, double\n"
		"mu=2000.0) Xapian::LM2StageWeight::LM2StageWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"lambda:  A parameter between 0 and 1 which linearly interpolates\n"
		"between the maximum likelihood model (at 0) and the collection model\n"
		"(at 1). Default: 0.7\n"
		"\n"
		"mu:  A parameter which is greater than 0. Default: 2000 \n"
		""},
	 { "LM2StageWeight_create_from_parameters", _wrap_LM2StageWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LM2StageWeight * Xapian::LM2StageWeight::create_from_parameters(const\n"
		"char *params) const Xapian::LM2StageWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LM2StageWeight", _wrap_delete_LM2StageWeight, METH_O, NULL},
	 { "LM2StageWeight_swigregister", LM2StageWeight_swigregister, METH_O, NULL},
	 { "LM2StageWeight_swiginit", LM2StageWeight_swiginit, METH_VARARGS, NULL},
	 { "CoordWeight_init", _wrap_CoordWeight_init, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Allow the subclass to perform any initialisation it needs to.\n"
		"\n"
		"void Xapian::CoordWeight::init(double factor_)\n"
		"Xapian::CoordWeight::init\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"factor:  Any scaling factor (e.g. from OP_SCALE_WEIGHT). If the Weight\n"
		"object is for the term-independent weight supplied by\n"
		"get_sumextra()/get_maxextra(), then init(0.0) is called (starting from\n"
		"Xapian 1.2.11 and 1.3.1 - earlier versions failed to call init() for\n"
		"such Weight objects). \n"
		""},
	 { "new_CoordWeight", _wrap_new_CoordWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a CoordWeight.\n"
		"\n"
		"Xapian::CoordWeight::CoordWeight() Xapian::CoordWeight::CoordWeight\n"
		""},
	 { "CoordWeight_create_from_parameters", _wrap_CoordWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"CoordWeight * Xapian::CoordWeight::create_from_parameters(const char\n"
		"*params) const Xapian::CoordWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_CoordWeight", _wrap_delete_CoordWeight, METH_O, NULL},
	 { "CoordWeight_swigregister", CoordWeight_swigregister, METH_O, NULL},
	 { "CoordWeight_swiginit", CoordWeight_swiginit, METH_VARARGS, NULL},
	 { "new_DiceWeight", _wrap_new_DiceWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a DiceWeight.\n"
		"\n"
		"Xapian::DiceWeight::DiceWeight() Xapian::DiceWeight::DiceWeight\n"
		""},
	 { "DiceWeight_create_from_parameters", _wrap_DiceWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"DiceWeight * Xapian::DiceWeight::create_from_parameters(const char\n"
		"*params) const Xapian::DiceWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_DiceWeight", _wrap_delete_DiceWeight, METH_O, NULL},
	 { "DiceWeight_swigregister", DiceWeight_swigregister, METH_O, NULL},
	 { "DiceWeight_swiginit", DiceWeight_swiginit, METH_VARARGS, NULL},
	 { "new_Compactor", _wrap_new_Compactor, METH_O, "Xapian::Compactor::Compactor() Xapian::Compactor::Compactor"},
	 { "delete_Compactor", _wrap_delete_Compactor, METH_O, "\n"
		"virtual\n"
		"Xapian::Compactor::~Compactor() Xapian::Compactor::~Compactor\n"
		""},
	 { "Compactor_set_status", _wrap_Compactor_set_status, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Update progress.\n"
		"\n"
		"virtual void Xapian::Compactor::set_status(const std::string &table,\n"
		"const std::string &status) Xapian::Compactor::set_status Subclass this\n"
		"method if you want to get progress updates during compaction. This is\n"
		"called for each table first with empty status, And then one or more\n"
		"times with non-empty status.\n"
		"\n"
		"The default implementation does nothing.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"table:  The table currently being compacted.\n"
		"\n"
		"status:  A status message. \n"
		""},
	 { "Compactor_resolve_duplicate_metadata", _wrap_Compactor_resolve_duplicate_metadata, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Resolve multiple user metadata entries with the same key.\n"
		"\n"
		"virtual std::string\n"
		"Xapian::Compactor::resolve_duplicate_metadata(const std::string &key,\n"
		"size_t num_tags, const std::string tags[])\n"
		"Xapian::Compactor::resolve_duplicate_metadata When merging, if the\n"
		"same user metadata key is set in more than one input, then this method\n"
		"is called to allow this to be resolving in an appropriate way.\n"
		"\n"
		"The default implementation just returns tags[0].\n"
		"\n"
		"For multipass this will currently get called multiple times for the\n"
		"same key if there are duplicates to resolve in each pass, but this may\n"
		"change in the future.\n"
		"\n"
		"Since 1.4.6, an implementation of this method can return an empty\n"
		"string to indicate that the appropriate result is to not set a value\n"
		"for this user metadata key in the output database. In older versions,\n"
		"you should not return an empty string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The metadata key with duplicate entries.\n"
		"\n"
		"num_tags:  How many tags there are.\n"
		"\n"
		"tags:  An array of num_tags strings containing the tags to merge. \n"
		""},
	 { "disown_Compactor", _wrap_disown_Compactor, METH_O, NULL},
	 { "Compactor_swigregister", Compactor_swigregister, METH_O, NULL},
	 { "Compactor_swiginit", Compactor_swiginit, METH_VARARGS, NULL},
	 { "new_PostingSource", _wrap_new_PostingSource, METH_O, "\n"
		"\n"
		"\n"
		"Allow subclasses to be instantiated.\n"
		"\n"
		"Xapian::PostingSource::PostingSource() noexcept\n"
		"Xapian::PostingSource::PostingSource\n"
		""},
	 { "delete_PostingSource", _wrap_delete_PostingSource, METH_O, "\n"
		"virtual\n"
		"Xapian::PostingSource::~PostingSource()\n"
		"Xapian::PostingSource::~PostingSource\n"
		""},
	 { "PostingSource_get_termfreq_min", _wrap_PostingSource_get_termfreq_min, METH_O, "\n"
		"\n"
		"\n"
		"A lower bound on the number of documents this object can return.\n"
		"\n"
		"virtual Xapian::doccount Xapian::PostingSource::get_termfreq_min()\n"
		"const =0 Xapian::PostingSource::get_termfreq_min  Xapian will always\n"
		"call reset() on a PostingSource before calling this for the first\n"
		"time. \n"
		""},
	 { "PostingSource_get_termfreq_est", _wrap_PostingSource_get_termfreq_est, METH_O, "\n"
		"\n"
		"\n"
		"An estimate of the number of documents this object can return.\n"
		"\n"
		"virtual Xapian::doccount Xapian::PostingSource::get_termfreq_est()\n"
		"const =0 Xapian::PostingSource::get_termfreq_est It must always be\n"
		"true that:\n"
		"\n"
		"get_termfreq_min() <= get_termfreq_est() <= get_termfreq_max()\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time. \n"
		""},
	 { "PostingSource_get_termfreq_max", _wrap_PostingSource_get_termfreq_max, METH_O, "\n"
		"\n"
		"\n"
		"An upper bound on the number of documents this object can return.\n"
		"\n"
		"virtual Xapian::doccount Xapian::PostingSource::get_termfreq_max()\n"
		"const =0 Xapian::PostingSource::get_termfreq_max  Xapian will always\n"
		"call reset() on a PostingSource before calling this for the first\n"
		"time. \n"
		""},
	 { "PostingSource_set_maxweight", _wrap_PostingSource_set_maxweight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify an upper bound on what get_weight() will return from now on.\n"
		"\n"
		"void Xapian::PostingSource::set_maxweight(double max_weight)\n"
		"Xapian::PostingSource::set_maxweight This upper bound is used by the\n"
		"matcher to perform various optimisations, so if you can return a good\n"
		"bound, then matches will generally run faster.\n"
		"\n"
		"This method should be called after calling reset(), and may be called\n"
		"during iteration if the upper bound drops. It is probably only useful\n"
		"to call from subclasses (it was actually a \"protected\" method prior\n"
		"to Xapian 1.3.4, but that makes it tricky to wrap for other\n"
		"languages).\n"
		"\n"
		"It is valid for the posting source to have returned a higher value\n"
		"from get_weight() earlier in the iteration, but the posting source\n"
		"must not return a higher value from get_weight() than the currently\n"
		"set upper bound, and the upper bound must not be increased (until\n"
		"reset() has been called).\n"
		"\n"
		"If you don't call this method, the upper bound will default to 0, for\n"
		"convenience when implementing \"weight-less\" PostingSource\n"
		"subclasses.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_weight:  The upper bound to set. \n"
		""},
	 { "PostingSource_get_maxweight", _wrap_PostingSource_get_maxweight, METH_O, "\n"
		"\n"
		"\n"
		"Return the currently set upper bound on what get_weight() can return.\n"
		"\n"
		"double Xapian::PostingSource::get_maxweight() const noexcept\n"
		"Xapian::PostingSource::get_maxweight\n"
		""},
	 { "PostingSource_get_weight", _wrap_PostingSource_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Return the weight contribution for the current document.\n"
		"\n"
		"virtual double Xapian::PostingSource::get_weight() const\n"
		"Xapian::PostingSource::get_weight This default implementation always\n"
		"returns 0, for convenience when implementing \"weight-less\"\n"
		"PostingSource subclasses.\n"
		"\n"
		"This method may assume that it will only be called when there is a\n"
		"\"current document\". In detail: Xapian will always call reset() on a\n"
		"PostingSource before calling this for the first time. It will also\n"
		"only call this if the PostingSource reports that it is pointing to a\n"
		"valid document (ie, it will not call it before calling at least one of\n"
		"next(), skip_to() or check(), and will ensure that the PostingSource\n"
		"is not at the end by calling at_end()). \n"
		""},
	 { "PostingSource_get_docid", _wrap_PostingSource_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Return the current docid.\n"
		"\n"
		"virtual Xapian::docid Xapian::PostingSource::get_docid() const =0\n"
		"Xapian::PostingSource::get_docid This method may assume that it will\n"
		"only be called when there is a \"current document\". See  get_weight()\n"
		"for details.\n"
		"\n"
		"Note: in the case of a multi-database search, the returned docid\n"
		"should be in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details. \n"
		""},
	 { "PostingSource___next__", _wrap_PostingSource___next__, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the current position to the next matching document.\n"
		"\n"
		"virtual void Xapian::PostingSource::next(double min_wt)=0\n"
		"Xapian::PostingSource::next The PostingSource starts before the first\n"
		"entry in the list, so next(), skip_to() or check() must be called\n"
		"before any methods which need the context of the current position.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "PostingSource_skip_to", _wrap_PostingSource_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance to the specified docid.\n"
		"\n"
		"virtual void Xapian::PostingSource::skip_to(Xapian::docid did, double\n"
		"min_wt) Xapian::PostingSource::skip_to If the specified docid isn't in\n"
		"the list, position ourselves on the first document after it (or\n"
		"at_end() if no greater docids are present).\n"
		"\n"
		"If the current position is already the specified docid, this method\n"
		"will leave the position unmodified.\n"
		"\n"
		"If the specified docid is earlier than the current position, the\n"
		"behaviour is unspecified. A sensible behaviour would be to leave the\n"
		"current position unmodified, but it is also reasonable to move to the\n"
		"specified docid.\n"
		"\n"
		"The default implementation calls next() repeatedly, which works but\n"
		"skip_to() can often be implemented much more efficiently.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to advance to.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "PostingSource_check", _wrap_PostingSource_check, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if the specified docid occurs.\n"
		"\n"
		"virtual bool Xapian::PostingSource::check(Xapian::docid did, double\n"
		"min_wt) Xapian::PostingSource::check The caller is required to ensure\n"
		"that the specified document id did actually exists in the database. If\n"
		"it does, it must move to that document id, and return true. If it does\n"
		"not, it may either:\n"
		"\n"
		"return true, having moved to a definite position (including\n"
		"\"at_end\"), which must be the same position as skip_to() would have\n"
		"moved to.\n"
		"\n"
		"or\n"
		"\n"
		"return false, having moved to an \"indeterminate\" position, such that\n"
		"a subsequent call to next() or skip_to() will move to the next\n"
		"matching position after did.\n"
		"\n"
		"Generally, this method should act like skip_to() and return true if\n"
		"that can be done at little extra cost.\n"
		"\n"
		"Otherwise it should simply check if a particular docid is present,\n"
		"returning true if it is, and false if it isn't.\n"
		"\n"
		"The default implementation calls skip_to() and always returns true.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to check.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "PostingSource_at_end", _wrap_PostingSource_at_end, METH_O, "\n"
		"\n"
		"\n"
		"Return true if the current position is past the last entry in this\n"
		"list.\n"
		"\n"
		"virtual bool Xapian::PostingSource::at_end() const =0\n"
		"Xapian::PostingSource::at_end At least one of  next(),  skip_to() or\n"
		"check() will be called before this method is first called. \n"
		""},
	 { "PostingSource_name", _wrap_PostingSource_name, METH_O, "\n"
		"\n"
		"\n"
		"Name of the posting source class.\n"
		"\n"
		"virtual std::string Xapian::PostingSource::name() const\n"
		"Xapian::PostingSource::name This is used when serialising and\n"
		"unserialising posting sources; for example, for performing remote\n"
		"searches.\n"
		"\n"
		"If the subclass is in a C++ namespace, the namespace should be\n"
		"included in the name, using \"::\" as a separator. For example, for a\n"
		"PostingSource subclass called \"FooPostingSource\" in the \"Xapian\"\n"
		"namespace the result of this call should be\n"
		"\"Xapian::FooPostingSource\".\n"
		"\n"
		"This should only be implemented if serialise() and unserialise() are\n"
		"also implemented. The default implementation returns an empty string.\n"
		"\n"
		"If this returns an empty string, Xapian will assume that serialise()\n"
		"and unserialise() are not implemented. \n"
		""},
	 { "PostingSource_reset", _wrap_PostingSource_reset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set this PostingSource to the start of the list of postings.\n"
		"\n"
		"virtual void Xapian::PostingSource::reset(const Database &db,\n"
		"Xapian::doccount shard_index) Xapian::PostingSource::reset This is\n"
		"called automatically by the matcher prior to each query being\n"
		"processed.\n"
		"\n"
		"If a PostingSource is used for multiple searches,  reset() will\n"
		"therefore be called multiple times, and must handle this by using the\n"
		"database passed in the most recent call.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database which the PostingSource should iterate through.\n"
		"\n"
		"shard_index:  The 0-based index indicating which shard in a multi-\n"
		"database db is. This can be useful if you have an external source of\n"
		"postings corresponding to each shard.\n"
		"\n"
		"Note: in the case of a multi-database search, a separate PostingSource\n"
		"will be used for each database (the separate PostingSources will be\n"
		"obtained using  clone()), and each PostingSource will be passed one of\n"
		"the sub-databases as the db parameter here. The db parameter will\n"
		"therefore always refer to a single database. All docids passed to, or\n"
		"returned from, the PostingSource refer to docids in that single\n"
		"database, rather than in the multi- database.\n"
		"\n"
		"A default implementation is provided which calls the older init()\n"
		"method to allow existing subclasses to continue to work, but the\n"
		"default implementation of init() throws Xapian::InvalidOperationError\n"
		"so you must override either this method or init(). In new code,\n"
		"override this method in preference.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "PostingSource_init", _wrap_PostingSource_init, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Older method which did the same job as reset().\n"
		"\n"
		"virtual void Xapian::PostingSource::init(const Database &db)\n"
		"Xapian::PostingSource::init Prior to 2.0.0, instead of reset() there\n"
		"was a method called init() taking one parameter. The default\n"
		"implementation of reset() calls init() to allow existing subclasses to\n"
		"continue to work.\n"
		"\n"
		"A default implementation of init() is provided so that new subclasses\n"
		"can just override reset() (the default implementation should not\n"
		"actually get called, and will throw Xapian::InvalidOperationError if\n"
		"it is). \n"
		""},
	 { "PostingSource___str__", _wrap_PostingSource___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::PostingSource::get_description() const\n"
		"Xapian::PostingSource::get_description This default implementation\n"
		"returns a generic answer. This default it provided to avoid forcing\n"
		"those deriving their own PostingSource subclass from having to\n"
		"implement this (they may not care what get_description() gives for\n"
		"their subclass). \n"
		""},
	 { "PostingSource_release", _wrap_PostingSource_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const PostingSource * Xapian::PostingSource::release() const\n"
		"Xapian::PostingSource::release You can transfer ownership of a\n"
		"dynamically allocated PostingSource object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_PostingSource", _wrap_disown_PostingSource, METH_O, NULL},
	 { "PostingSource_swigregister", PostingSource_swigregister, METH_O, NULL},
	 { "PostingSource_swiginit", PostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_ValuePostingSource", _wrap_new_ValuePostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a ValuePostingSource.\n"
		"\n"
		"Xapian::ValuePostingSource::ValuePostingSource(Xapian::valueno slot_)\n"
		"noexcept Xapian::ValuePostingSource::ValuePostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from. \n"
		""},
	 { "ValuePostingSource_get_termfreq_min", _wrap_ValuePostingSource_get_termfreq_min, METH_O, "\n"
		"\n"
		"\n"
		"A lower bound on the number of documents this object can return.\n"
		"\n"
		"Xapian::doccount Xapian::ValuePostingSource::get_termfreq_min() const\n"
		"Xapian::ValuePostingSource::get_termfreq_min  Xapian will always call\n"
		"reset() on a PostingSource before calling this for the first time. \n"
		""},
	 { "ValuePostingSource_get_termfreq_est", _wrap_ValuePostingSource_get_termfreq_est, METH_O, "\n"
		"\n"
		"\n"
		"An estimate of the number of documents this object can return.\n"
		"\n"
		"Xapian::doccount Xapian::ValuePostingSource::get_termfreq_est() const\n"
		"Xapian::ValuePostingSource::get_termfreq_est It must always be true\n"
		"that:\n"
		"\n"
		"get_termfreq_min() <= get_termfreq_est() <= get_termfreq_max()\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time. \n"
		""},
	 { "ValuePostingSource_get_termfreq_max", _wrap_ValuePostingSource_get_termfreq_max, METH_O, "\n"
		"\n"
		"\n"
		"An upper bound on the number of documents this object can return.\n"
		"\n"
		"Xapian::doccount Xapian::ValuePostingSource::get_termfreq_max() const\n"
		"Xapian::ValuePostingSource::get_termfreq_max  Xapian will always call\n"
		"reset() on a PostingSource before calling this for the first time. \n"
		""},
	 { "ValuePostingSource___next__", _wrap_ValuePostingSource___next__, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the current position to the next matching document.\n"
		"\n"
		"void Xapian::ValuePostingSource::next(double min_wt)\n"
		"Xapian::ValuePostingSource::next The PostingSource starts before the\n"
		"first entry in the list, so next(), skip_to() or check() must be\n"
		"called before any methods which need the context of the current\n"
		"position.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "ValuePostingSource_skip_to", _wrap_ValuePostingSource_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance to the specified docid.\n"
		"\n"
		"void Xapian::ValuePostingSource::skip_to(Xapian::docid min_docid,\n"
		"double min_wt) Xapian::ValuePostingSource::skip_to If the specified\n"
		"docid isn't in the list, position ourselves on the first document\n"
		"after it (or at_end() if no greater docids are present).\n"
		"\n"
		"If the current position is already the specified docid, this method\n"
		"will leave the position unmodified.\n"
		"\n"
		"If the specified docid is earlier than the current position, the\n"
		"behaviour is unspecified. A sensible behaviour would be to leave the\n"
		"current position unmodified, but it is also reasonable to move to the\n"
		"specified docid.\n"
		"\n"
		"The default implementation calls next() repeatedly, which works but\n"
		"skip_to() can often be implemented much more efficiently.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to advance to.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "ValuePostingSource_check", _wrap_ValuePostingSource_check, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if the specified docid occurs.\n"
		"\n"
		"bool Xapian::ValuePostingSource::check(Xapian::docid min_docid, double\n"
		"min_wt) Xapian::ValuePostingSource::check The caller is required to\n"
		"ensure that the specified document id did actually exists in the\n"
		"database. If it does, it must move to that document id, and return\n"
		"true. If it does not, it may either:\n"
		"\n"
		"return true, having moved to a definite position (including\n"
		"\"at_end\"), which must be the same position as skip_to() would have\n"
		"moved to.\n"
		"\n"
		"or\n"
		"\n"
		"return false, having moved to an \"indeterminate\" position, such that\n"
		"a subsequent call to next() or skip_to() will move to the next\n"
		"matching position after did.\n"
		"\n"
		"Generally, this method should act like skip_to() and return true if\n"
		"that can be done at little extra cost.\n"
		"\n"
		"Otherwise it should simply check if a particular docid is present,\n"
		"returning true if it is, and false if it isn't.\n"
		"\n"
		"The default implementation calls skip_to() and always returns true.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to check.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "ValuePostingSource_at_end", _wrap_ValuePostingSource_at_end, METH_O, "\n"
		"\n"
		"\n"
		"Return true if the current position is past the last entry in this\n"
		"list.\n"
		"\n"
		"bool Xapian::ValuePostingSource::at_end() const\n"
		"Xapian::ValuePostingSource::at_end At least one of  next(),  skip_to()\n"
		"or  check() will be called before this method is first called. \n"
		""},
	 { "ValuePostingSource_get_docid", _wrap_ValuePostingSource_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Return the current docid.\n"
		"\n"
		"Xapian::docid Xapian::ValuePostingSource::get_docid() const\n"
		"Xapian::ValuePostingSource::get_docid This method may assume that it\n"
		"will only be called when there is a \"current document\". See\n"
		"get_weight() for details.\n"
		"\n"
		"Note: in the case of a multi-database search, the returned docid\n"
		"should be in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details. \n"
		""},
	 { "ValuePostingSource_reset", _wrap_ValuePostingSource_reset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set this PostingSource to the start of the list of postings.\n"
		"\n"
		"void Xapian::ValuePostingSource::reset(const Database &db_,\n"
		"Xapian::doccount shard_index) Xapian::ValuePostingSource::reset This\n"
		"is called automatically by the matcher prior to each query being\n"
		"processed.\n"
		"\n"
		"If a PostingSource is used for multiple searches,  reset() will\n"
		"therefore be called multiple times, and must handle this by using the\n"
		"database passed in the most recent call.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database which the PostingSource should iterate through.\n"
		"\n"
		"shard_index:  The 0-based index indicating which shard in a multi-\n"
		"database db is. This can be useful if you have an external source of\n"
		"postings corresponding to each shard.\n"
		"\n"
		"Note: in the case of a multi-database search, a separate PostingSource\n"
		"will be used for each database (the separate PostingSources will be\n"
		"obtained using  clone()), and each PostingSource will be passed one of\n"
		"the sub-databases as the db parameter here. The db parameter will\n"
		"therefore always refer to a single database. All docids passed to, or\n"
		"returned from, the PostingSource refer to docids in that single\n"
		"database, rather than in the multi- database.\n"
		"\n"
		"A default implementation is provided which calls the older init()\n"
		"method to allow existing subclasses to continue to work, but the\n"
		"default implementation of init() throws Xapian::InvalidOperationError\n"
		"so you must override either this method or init(). In new code,\n"
		"override this method in preference.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "ValuePostingSource_get_database", _wrap_ValuePostingSource_get_database, METH_O, "\n"
		"\n"
		"\n"
		"The database we're reading values from.\n"
		"\n"
		"Xapian::Database Xapian::ValuePostingSource::get_database() const\n"
		"Xapian::ValuePostingSource::get_database\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_get_slot", _wrap_ValuePostingSource_get_slot, METH_O, "\n"
		"\n"
		"\n"
		"The slot we're reading values from.\n"
		"\n"
		"Xapian::valueno Xapian::ValuePostingSource::get_slot() const\n"
		"Xapian::ValuePostingSource::get_slot\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_get_value", _wrap_ValuePostingSource_get_value, METH_O, "\n"
		"\n"
		"\n"
		"Read current value.\n"
		"\n"
		"std::string Xapian::ValuePostingSource::get_value() const\n"
		"Xapian::ValuePostingSource::get_value\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_done", _wrap_ValuePostingSource_done, METH_O, "\n"
		"\n"
		"\n"
		"End the iteration.\n"
		"\n"
		"void Xapian::ValuePostingSource::done()\n"
		"Xapian::ValuePostingSource::done Calls to at_end() will return true\n"
		"after calling this method.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_get_started", _wrap_ValuePostingSource_get_started, METH_O, "\n"
		"\n"
		"\n"
		"Flag indicating if we've started (true if we have).\n"
		"\n"
		"bool Xapian::ValuePostingSource::get_started() const\n"
		"Xapian::ValuePostingSource::get_started\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_set_termfreq_min", _wrap_ValuePostingSource_set_termfreq_min, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set a lower bound on the term frequency.\n"
		"\n"
		"void Xapian::ValuePostingSource::set_termfreq_min(Xapian::doccount\n"
		"termfreq_min_) Xapian::ValuePostingSource::set_termfreq_min Subclasses\n"
		"should set this if they are overriding the next(), skip_to() or\n"
		"check() methods to return fewer documents.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_set_termfreq_est", _wrap_ValuePostingSource_set_termfreq_est, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An estimate of the term frequency.\n"
		"\n"
		"void Xapian::ValuePostingSource::set_termfreq_est(Xapian::doccount\n"
		"termfreq_est_) Xapian::ValuePostingSource::set_termfreq_est Subclasses\n"
		"should set this if they are overriding the next(), skip_to() or\n"
		"check() methods.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_set_termfreq_max", _wrap_ValuePostingSource_set_termfreq_max, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An upper bound on the term frequency.\n"
		"\n"
		"void Xapian::ValuePostingSource::set_termfreq_max(Xapian::doccount\n"
		"termfreq_max_) Xapian::ValuePostingSource::set_termfreq_max Subclasses\n"
		"should set this if they are overriding the next(), skip_to() or\n"
		"check() methods.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource___str__", _wrap_ValuePostingSource___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ValuePostingSource::get_description() const\n"
		"Xapian::ValuePostingSource::get_description This default\n"
		"implementation returns a generic answer. This default it provided to\n"
		"avoid forcing those deriving their own PostingSource subclass from\n"
		"having to implement this (they may not care what get_description()\n"
		"gives for their subclass). \n"
		""},
	 { "delete_ValuePostingSource", _wrap_delete_ValuePostingSource, METH_O, NULL},
	 { "disown_ValuePostingSource", _wrap_disown_ValuePostingSource, METH_O, NULL},
	 { "ValuePostingSource_swigregister", ValuePostingSource_swigregister, METH_O, NULL},
	 { "ValuePostingSource_swiginit", ValuePostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_ValueWeightPostingSource", _wrap_new_ValueWeightPostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a ValueWeightPostingSource.\n"
		"\n"
		"Xapian::ValueWeightPostingSource::ValueWeightPostingSource(Xapian::valueno\n"
		"slot_) Xapian::ValueWeightPostingSource::ValueWeightPostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from. \n"
		""},
	 { "ValueWeightPostingSource_get_weight", _wrap_ValueWeightPostingSource_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Return the weight contribution for the current document.\n"
		"\n"
		"double Xapian::ValueWeightPostingSource::get_weight() const\n"
		"Xapian::ValueWeightPostingSource::get_weight This default\n"
		"implementation always returns 0, for convenience when implementing\n"
		"\"weight-less\" PostingSource subclasses.\n"
		"\n"
		"This method may assume that it will only be called when there is a\n"
		"\"current document\". In detail: Xapian will always call reset() on a\n"
		"PostingSource before calling this for the first time. It will also\n"
		"only call this if the PostingSource reports that it is pointing to a\n"
		"valid document (ie, it will not call it before calling at least one of\n"
		"next(), skip_to() or check(), and will ensure that the PostingSource\n"
		"is not at the end by calling at_end()). \n"
		""},
	 { "ValueWeightPostingSource_name", _wrap_ValueWeightPostingSource_name, METH_O, "\n"
		"\n"
		"\n"
		"Name of the posting source class.\n"
		"\n"
		"std::string Xapian::ValueWeightPostingSource::name() const\n"
		"Xapian::ValueWeightPostingSource::name This is used when serialising\n"
		"and unserialising posting sources; for example, for performing remote\n"
		"searches.\n"
		"\n"
		"If the subclass is in a C++ namespace, the namespace should be\n"
		"included in the name, using \"::\" as a separator. For example, for a\n"
		"PostingSource subclass called \"FooPostingSource\" in the \"Xapian\"\n"
		"namespace the result of this call should be\n"
		"\"Xapian::FooPostingSource\".\n"
		"\n"
		"This should only be implemented if serialise() and unserialise() are\n"
		"also implemented. The default implementation returns an empty string.\n"
		"\n"
		"If this returns an empty string, Xapian will assume that serialise()\n"
		"and unserialise() are not implemented. \n"
		""},
	 { "ValueWeightPostingSource_reset", _wrap_ValueWeightPostingSource_reset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set this PostingSource to the start of the list of postings.\n"
		"\n"
		"void Xapian::ValueWeightPostingSource::reset(const Database &db_,\n"
		"Xapian::doccount shard_index) Xapian::ValueWeightPostingSource::reset\n"
		"This is called automatically by the matcher prior to each query being\n"
		"processed.\n"
		"\n"
		"If a PostingSource is used for multiple searches,  reset() will\n"
		"therefore be called multiple times, and must handle this by using the\n"
		"database passed in the most recent call.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database which the PostingSource should iterate through.\n"
		"\n"
		"shard_index:  The 0-based index indicating which shard in a multi-\n"
		"database db is. This can be useful if you have an external source of\n"
		"postings corresponding to each shard.\n"
		"\n"
		"Note: in the case of a multi-database search, a separate PostingSource\n"
		"will be used for each database (the separate PostingSources will be\n"
		"obtained using  clone()), and each PostingSource will be passed one of\n"
		"the sub-databases as the db parameter here. The db parameter will\n"
		"therefore always refer to a single database. All docids passed to, or\n"
		"returned from, the PostingSource refer to docids in that single\n"
		"database, rather than in the multi- database.\n"
		"\n"
		"A default implementation is provided which calls the older init()\n"
		"method to allow existing subclasses to continue to work, but the\n"
		"default implementation of init() throws Xapian::InvalidOperationError\n"
		"so you must override either this method or init(). In new code,\n"
		"override this method in preference.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "ValueWeightPostingSource___str__", _wrap_ValueWeightPostingSource___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ValueWeightPostingSource::get_description() const\n"
		"Xapian::ValueWeightPostingSource::get_description This default\n"
		"implementation returns a generic answer. This default it provided to\n"
		"avoid forcing those deriving their own PostingSource subclass from\n"
		"having to implement this (they may not care what get_description()\n"
		"gives for their subclass). \n"
		""},
	 { "delete_ValueWeightPostingSource", _wrap_delete_ValueWeightPostingSource, METH_O, NULL},
	 { "disown_ValueWeightPostingSource", _wrap_disown_ValueWeightPostingSource, METH_O, NULL},
	 { "ValueWeightPostingSource_swigregister", ValueWeightPostingSource_swigregister, METH_O, NULL},
	 { "ValueWeightPostingSource_swiginit", ValueWeightPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_DecreasingValueWeightPostingSource", _wrap_new_DecreasingValueWeightPostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a DecreasingValueWeightPostingSource.\n"
		"\n"
		"Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPostingSource(Xapian::valueno\n"
		"slot_, Xapian::docid range_start_=0, Xapian::docid range_end_=0)\n"
		"Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPosti\n"
		"ngSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from.\n"
		"\n"
		"range_start_:  Start of range of docids for which weights are known to\n"
		"be decreasing (default: first docid)\n"
		"\n"
		"range_end_:  End of range of docids for which weights are known to be\n"
		"decreasing (default: last docid) \n"
		""},
	 { "delete_DecreasingValueWeightPostingSource", _wrap_delete_DecreasingValueWeightPostingSource, METH_O, NULL},
	 { "DecreasingValueWeightPostingSource_swigregister", DecreasingValueWeightPostingSource_swigregister, METH_O, NULL},
	 { "DecreasingValueWeightPostingSource_swiginit", DecreasingValueWeightPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_ValueMapPostingSource", _wrap_new_ValueMapPostingSource, METH_O, "\n"
		"\n"
		"\n"
		"Construct a ValueMapPostingSource.\n"
		"\n"
		"Xapian::ValueMapPostingSource::ValueMapPostingSource(Xapian::valueno\n"
		"slot_) Xapian::ValueMapPostingSource::ValueMapPostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from. \n"
		""},
	 { "ValueMapPostingSource_add_mapping", _wrap_ValueMapPostingSource_add_mapping, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a mapping.\n"
		"\n"
		"void Xapian::ValueMapPostingSource::add_mapping(const std::string\n"
		"&key, double wt) Xapian::ValueMapPostingSource::add_mapping\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The key looked up from the value slot.\n"
		"\n"
		"wt:  The weight to give this key. \n"
		""},
	 { "ValueMapPostingSource_clear_mappings", _wrap_ValueMapPostingSource_clear_mappings, METH_O, "\n"
		"\n"
		"\n"
		"Clear all mappings.\n"
		"\n"
		"void Xapian::ValueMapPostingSource::clear_mappings()\n"
		"Xapian::ValueMapPostingSource::clear_mappings\n"
		""},
	 { "ValueMapPostingSource_set_default_weight", _wrap_ValueMapPostingSource_set_default_weight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set a default weight for document values not in the map.\n"
		"\n"
		"void Xapian::ValueMapPostingSource::set_default_weight(double wt)\n"
		"Xapian::ValueMapPostingSource::set_default_weight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wt:  The weight to set as the default. \n"
		""},
	 { "delete_ValueMapPostingSource", _wrap_delete_ValueMapPostingSource, METH_O, NULL},
	 { "ValueMapPostingSource_swigregister", ValueMapPostingSource_swigregister, METH_O, NULL},
	 { "ValueMapPostingSource_swiginit", ValueMapPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_FixedWeightPostingSource", _wrap_new_FixedWeightPostingSource, METH_O, "\n"
		"\n"
		"\n"
		"Construct a FixedWeightPostingSource.\n"
		"\n"
		"Xapian::FixedWeightPostingSource::FixedWeightPostingSource(double wt)\n"
		"Xapian::FixedWeightPostingSource::FixedWeightPostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wt:  The fixed weight to return. \n"
		""},
	 { "delete_FixedWeightPostingSource", _wrap_delete_FixedWeightPostingSource, METH_O, NULL},
	 { "FixedWeightPostingSource_swigregister", FixedWeightPostingSource_swigregister, METH_O, NULL},
	 { "FixedWeightPostingSource_swiginit", FixedWeightPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_MatchSpy", _wrap_new_MatchSpy, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor, needed by subclass constructors.\n"
		"\n"
		"Xapian::MatchSpy::MatchSpy() noexcept Xapian::MatchSpy::MatchSpy\n"
		""},
	 { "delete_MatchSpy", _wrap_delete_MatchSpy, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::MatchSpy::~MatchSpy() Xapian::MatchSpy::~MatchSpy\n"
		""},
	 { "MatchSpy___call__", _wrap_MatchSpy___call__, METH_VARARGS, NULL},
	 { "MatchSpy_name", _wrap_MatchSpy_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the name of this match spy.\n"
		"\n"
		"virtual std::string Xapian::MatchSpy::name() const\n"
		"Xapian::MatchSpy::name This name is used by the remote backend. It is\n"
		"passed with the serialised parameters to the remote server so that it\n"
		"knows which class to create.\n"
		"\n"
		"Return the full namespace-qualified name of your class here - if your\n"
		"class is called MyApp::FooMatchSpy, return \"MyApp::FooMatchSpy\" from\n"
		"this method.\n"
		"\n"
		"If you don't want to support the remote backend in your match spy, you\n"
		"can use the default implementation which simply throws\n"
		"Xapian::UnimplementedError. \n"
		""},
	 { "MatchSpy_merge_results", _wrap_MatchSpy_merge_results, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unserialise some results, and merge them into this matchspy.\n"
		"\n"
		"virtual void Xapian::MatchSpy::merge_results(const std::string\n"
		"&serialised) Xapian::MatchSpy::merge_results The order in which\n"
		"results are merged should not be significant, since this order is not\n"
		"specified (and will vary depending on the speed of the search in each\n"
		"sub-database).\n"
		"\n"
		"If you don't want to support the remote backend in your match spy, you\n"
		"can use the default implementation which simply throws\n"
		"Xapian::UnimplementedError.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"serialised:  A string containing the serialised results. \n"
		""},
	 { "MatchSpy___str__", _wrap_MatchSpy___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::MatchSpy::get_description() const\n"
		"Xapian::MatchSpy::get_description This default implementation returns\n"
		"a generic answer, to avoid forcing those deriving their own MatchSpy\n"
		"subclasses from having to implement this (they may not care what\n"
		"get_description() gives for their subclass). \n"
		""},
	 { "MatchSpy_release", _wrap_MatchSpy_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const MatchSpy * Xapian::MatchSpy::release() const\n"
		"Xapian::MatchSpy::release You can transfer ownership of a dynamically\n"
		"allocated MatchSpy object to Xapian by calling release() and then\n"
		"passing the object to a Xapian method. Xapian will arrange to delete\n"
		"the object once it is no longer required. \n"
		""},
	 { "disown_MatchSpy", _wrap_disown_MatchSpy, METH_O, NULL},
	 { "MatchSpy_swigregister", MatchSpy_swigregister, METH_O, NULL},
	 { "MatchSpy_swiginit", MatchSpy_swiginit, METH_VARARGS, NULL},
	 { "new_ValueCountMatchSpy", _wrap_new_ValueCountMatchSpy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a MatchSpy which counts the values in a particular slot.\n"
		"\n"
		"Xapian::ValueCountMatchSpy::ValueCountMatchSpy(Xapian::valueno slot_)\n"
		"Xapian::ValueCountMatchSpy::ValueCountMatchSpy\n"
		""},
	 { "ValueCountMatchSpy_get_total", _wrap_ValueCountMatchSpy_get_total, METH_O, "\n"
		"\n"
		"\n"
		"Return the total number of documents tallied.\n"
		"\n"
		"size_t Xapian::ValueCountMatchSpy::get_total() const noexcept\n"
		"Xapian::ValueCountMatchSpy::get_total\n"
		""},
	 { "ValueCountMatchSpy_values_begin", _wrap_ValueCountMatchSpy_values_begin, METH_O, "\n"
		"\n"
		"\n"
		"Get an iterator over the values seen in the slot.\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::values_begin() const\n"
		"Xapian::ValueCountMatchSpy::values_begin Items will be returned in\n"
		"ascending alphabetical order.\n"
		"\n"
		"During the iteration, the frequency of the current value can be\n"
		"obtained with the get_termfreq() method on the iterator. \n"
		""},
	 { "ValueCountMatchSpy_values_end", _wrap_ValueCountMatchSpy_values_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to values_begin().\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::values_end() const noexcept\n"
		"Xapian::ValueCountMatchSpy::values_end\n"
		""},
	 { "ValueCountMatchSpy_top_values_begin", _wrap_ValueCountMatchSpy_top_values_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get an iterator over the most frequent values seen in the slot.\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::top_values_begin(size_t\n"
		"maxvalues) const Xapian::ValueCountMatchSpy::top_values_begin Items\n"
		"will be returned in descending order of frequency. Values with the\n"
		"same frequency will be returned in ascending alphabetical order.\n"
		"\n"
		"During the iteration, the frequency of the current value can be\n"
		"obtained with the get_termfreq() method on the iterator.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"maxvalues:  The maximum number of values to return. \n"
		""},
	 { "ValueCountMatchSpy_top_values_end", _wrap_ValueCountMatchSpy_top_values_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to top_values_begin().\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::top_values_end(size_t) const\n"
		"noexcept Xapian::ValueCountMatchSpy::top_values_end\n"
		""},
	 { "delete_ValueCountMatchSpy", _wrap_delete_ValueCountMatchSpy, METH_O, NULL},
	 { "ValueCountMatchSpy_swigregister", ValueCountMatchSpy_swigregister, METH_O, NULL},
	 { "ValueCountMatchSpy_swiginit", ValueCountMatchSpy_swiginit, METH_VARARGS, NULL},
	 { "miles_to_metres", _wrap_miles_to_metres, METH_O, NULL},
	 { "metres_to_miles", _wrap_metres_to_miles, METH_O, NULL},
	 { "LatLongCoord_latitude_set", _wrap_LatLongCoord_latitude_set, METH_VARARGS, NULL},
	 { "LatLongCoord_latitude_get", _wrap_LatLongCoord_latitude_get, METH_O, NULL},
	 { "LatLongCoord_longitude_set", _wrap_LatLongCoord_longitude_set, METH_VARARGS, NULL},
	 { "LatLongCoord_longitude_get", _wrap_LatLongCoord_longitude_get, METH_O, NULL},
	 { "new_LatLongCoord", _wrap_new_LatLongCoord, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a coordinate.\n"
		"\n"
		"Xapian::LatLongCoord::LatLongCoord(double latitude_, double\n"
		"longitude_) Xapian::LatLongCoord::LatLongCoord If the supplied\n"
		"longitude is out of the standard range, it will be normalised to the\n"
		"range 0 <= longitude < 360.\n"
		"\n"
		"If you want to avoid the checks (for example, you know that your\n"
		"values are already in range), you can use the alternate constructor to\n"
		"construct an uninitialised coordinate, and then set the latitude and\n"
		"longitude directly.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"InvalidArgumentError:  the supplied latitude is out of range. \n"
		""},
	 { "LatLongCoord_unserialise", _wrap_LatLongCoord_unserialise, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unserialise a buffer and set this object to its coordinate.\n"
		"\n"
		"void Xapian::LatLongCoord::unserialise(const char **ptr, const char\n"
		"*end) Xapian::LatLongCoord::unserialise The buffer may contain further\n"
		"data after that for the coordinate.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"ptr:  A pointer to the start of the string. This will be updated to\n"
		"point to the end of the data representing the coordinate.\n"
		"\n"
		"end:  A pointer to the end of the string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::SerialisationError:  if the string does not start with a valid\n"
		"serialised latitude- longitude pair. \n"
		""},
	 { "LatLongCoord_serialise", _wrap_LatLongCoord_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Return a serialised representation of the coordinate.\n"
		"\n"
		"std::string Xapian::LatLongCoord::serialise() const\n"
		"Xapian::LatLongCoord::serialise\n"
		""},
	 { "LatLongCoord___str__", _wrap_LatLongCoord___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::LatLongCoord::get_description() const\n"
		"Xapian::LatLongCoord::get_description\n"
		""},
	 { "delete_LatLongCoord", _wrap_delete_LatLongCoord, METH_O, NULL},
	 { "LatLongCoord_swigregister", LatLongCoord_swigregister, METH_O, NULL},
	 { "LatLongCoord_swiginit", LatLongCoord_swiginit, METH_VARARGS, NULL},
	 { "new_LatLongCoordsIterator", _wrap_new_LatLongCoordsIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor. Produces an uninitialised iterator.\n"
		"\n"
		"Xapian::LatLongCoordsIterator::LatLongCoordsIterator()\n"
		"Xapian::LatLongCoordsIterator::LatLongCoordsIterator\n"
		""},
	 { "LatLongCoordsIterator___eq__", _wrap_LatLongCoordsIterator___eq__, METH_VARARGS, NULL},
	 { "LatLongCoordsIterator_equals", _wrap_LatLongCoordsIterator_equals, METH_VARARGS, NULL},
	 { "LatLongCoordsIterator_get_coord", _wrap_LatLongCoordsIterator_get_coord, METH_O, NULL},
	 { "LatLongCoordsIterator___next__", _wrap_LatLongCoordsIterator___next__, METH_O, NULL},
	 { "delete_LatLongCoordsIterator", _wrap_delete_LatLongCoordsIterator, METH_O, NULL},
	 { "LatLongCoordsIterator_swigregister", LatLongCoordsIterator_swigregister, METH_O, NULL},
	 { "LatLongCoordsIterator_swiginit", LatLongCoordsIterator_swiginit, METH_VARARGS, NULL},
	 { "LatLongCoords_begin", _wrap_LatLongCoords_begin, METH_O, "\n"
		"\n"
		"\n"
		"Get a begin iterator for the coordinates.\n"
		"\n"
		"LatLongCoordsIterator Xapian::LatLongCoords::begin() const\n"
		"Xapian::LatLongCoords::begin\n"
		""},
	 { "LatLongCoords_end", _wrap_LatLongCoords_end, METH_O, "\n"
		"\n"
		"\n"
		"Get an end iterator for the coordinates.\n"
		"\n"
		"LatLongCoordsIterator Xapian::LatLongCoords::end() const\n"
		"Xapian::LatLongCoords::end\n"
		""},
	 { "LatLongCoords_size", _wrap_LatLongCoords_size, METH_O, "\n"
		"\n"
		"\n"
		"Get the number of coordinates in the container.\n"
		"\n"
		"size_t Xapian::LatLongCoords::size() const\n"
		"Xapian::LatLongCoords::size\n"
		""},
	 { "LatLongCoords_empty", _wrap_LatLongCoords_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if and only if there are no coordinates in the container.\n"
		"\n"
		"bool Xapian::LatLongCoords::empty() const\n"
		"Xapian::LatLongCoords::empty\n"
		""},
	 { "LatLongCoords_append", _wrap_LatLongCoords_append, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Append a coordinate to the end of the sequence.\n"
		"\n"
		"void Xapian::LatLongCoords::append(const LatLongCoord &coord)\n"
		"Xapian::LatLongCoords::append\n"
		""},
	 { "new_LatLongCoords", _wrap_new_LatLongCoords, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a container holding one coordinate.\n"
		"\n"
		"Xapian::LatLongCoords::LatLongCoords(const LatLongCoord &coord)\n"
		"Xapian::LatLongCoords::LatLongCoords\n"
		""},
	 { "LatLongCoords_unserialise", _wrap_LatLongCoords_unserialise, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unserialise a string and set this object to the coordinates in it.\n"
		"\n"
		"void Xapian::LatLongCoords::unserialise(std::string_view serialised)\n"
		"Xapian::LatLongCoords::unserialise\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"serialised:  the string to unserialise the coordinates from.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::SerialisationError:  if the string does not contain a valid\n"
		"serialised latitude-longitude pair, or contains junk at the end of it.\n"
		"\n"
		""},
	 { "LatLongCoords_serialise", _wrap_LatLongCoords_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Return a serialised form of the coordinate list.\n"
		"\n"
		"std::string Xapian::LatLongCoords::serialise() const\n"
		"Xapian::LatLongCoords::serialise\n"
		""},
	 { "LatLongCoords___str__", _wrap_LatLongCoords___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::LatLongCoords::get_description() const\n"
		"Xapian::LatLongCoords::get_description\n"
		""},
	 { "delete_LatLongCoords", _wrap_delete_LatLongCoords, METH_O, NULL},
	 { "LatLongCoords_swigregister", LatLongCoords_swigregister, METH_O, NULL},
	 { "LatLongCoords_swiginit", LatLongCoords_swiginit, METH_VARARGS, NULL},
	 { "__ne__", _wrap___ne__, METH_VARARGS, NULL},
	 { "delete_LatLongMetric", _wrap_delete_LatLongMetric, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::LatLongMetric::~LatLongMetric()\n"
		"Xapian::LatLongMetric::~LatLongMetric\n"
		""},
	 { "LatLongMetric_pointwise_distance", _wrap_LatLongMetric_pointwise_distance, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return the distance between two coordinates, in metres.\n"
		"\n"
		"virtual double Xapian::LatLongMetric::pointwise_distance(const\n"
		"LatLongCoord &a, const LatLongCoord &b) const =0\n"
		"Xapian::LatLongMetric::pointwise_distance\n"
		""},
	 { "LatLongMetric___call__", _wrap_LatLongMetric___call__, METH_VARARGS, NULL},
	 { "LatLongMetric_name", _wrap_LatLongMetric_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the full name of the metric.\n"
		"\n"
		"virtual std::string Xapian::LatLongMetric::name() const =0\n"
		"Xapian::LatLongMetric::name This is used when serialising and\n"
		"unserialising metrics; for example, for performing remote searches.\n"
		"\n"
		"If the subclass is in a C++ namespace, the namespace should be\n"
		"included in the name, using \"::\" as a separator. For example, for a\n"
		"LatLongMetric subclass called \"FooLatLongMetric\" in the \"Xapian\"\n"
		"namespace the result of this call should be\n"
		"\"Xapian::FooLatLongMetric\". \n"
		""},
	 { "new_LatLongMetric", _wrap_new_LatLongMetric, METH_O, NULL},
	 { "disown_LatLongMetric", _wrap_disown_LatLongMetric, METH_O, NULL},
	 { "LatLongMetric_swigregister", LatLongMetric_swigregister, METH_O, NULL},
	 { "LatLongMetric_swiginit", LatLongMetric_swiginit, METH_VARARGS, NULL},
	 { "new_GreatCircleMetric", _wrap_new_GreatCircleMetric, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a GreatCircleMetric using a specified radius.\n"
		"\n"
		"Xapian::GreatCircleMetric::GreatCircleMetric(double radius_)\n"
		"Xapian::GreatCircleMetric::GreatCircleMetric This is useful for data\n"
		"sets in which the points are not on Earth (eg, a database of features\n"
		"on Mars).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"radius_:  The radius of the sphere to use, in metres. \n"
		""},
	 { "delete_GreatCircleMetric", _wrap_delete_GreatCircleMetric, METH_O, NULL},
	 { "GreatCircleMetric_swigregister", GreatCircleMetric_swigregister, METH_O, NULL},
	 { "GreatCircleMetric_swiginit", GreatCircleMetric_swiginit, METH_VARARGS, NULL},
	 { "new_LatLongDistancePostingSource", _wrap_new_LatLongDistancePostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a new posting source which returns only documents within\n"
		"range of one of the central coordinates.\n"
		"\n"
		"Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno\n"
		"slot_, const LatLongCoords &centre_, double max_range_=0.0, double\n"
		"k1_=1000.0, double k2_=1.0)\n"
		"Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from.\n"
		"\n"
		"centre_:  The centre point to use for distance calculations.\n"
		"\n"
		"max_range_:  The maximum distance for documents which are returned.\n"
		"\n"
		"k1_:  The k1 constant to use in the weighting function.\n"
		"\n"
		"k2_:  The k2 constant to use in the weighting function.\n"
		"\n"
		"Xapian::GreatCircleMetric is used as the metric. \n"
		""},
	 { "delete_LatLongDistancePostingSource", _wrap_delete_LatLongDistancePostingSource, METH_O, "\n"
		"Xapian::LatLongDistancePostingSource::~LatLongDistancePostingSource()\n"
		"Xapian::LatLongDistancePostingSource::~LatLongDistancePostingSource\n"
		""},
	 { "LatLongDistancePostingSource_swigregister", LatLongDistancePostingSource_swigregister, METH_O, NULL},
	 { "LatLongDistancePostingSource_swiginit", LatLongDistancePostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_LatLongDistanceKeyMaker", _wrap_new_LatLongDistanceKeyMaker, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LatLongDistanceKeyMaker.\n"
		"\n"
		"Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno\n"
		"slot_, const LatLongCoord &centre_)\n"
		"Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  Value slot to use.\n"
		"\n"
		"centre_:   Point to calculate distance from.\n"
		"\n"
		"Xapian::GreatCircleMetric is used as the metric.\n"
		"\n"
		"Documents where no value is set are assumed to be a large distance\n"
		"away. \n"
		""},
	 { "delete_LatLongDistanceKeyMaker", _wrap_delete_LatLongDistanceKeyMaker, METH_O, "\n"
		"Xapian::LatLongDistanceKeyMaker::~LatLongDistanceKeyMaker()\n"
		"Xapian::LatLongDistanceKeyMaker::~LatLongDistanceKeyMaker\n"
		""},
	 { "LatLongDistanceKeyMaker_swigregister", LatLongDistanceKeyMaker_swigregister, METH_O, NULL},
	 { "LatLongDistanceKeyMaker_swiginit", LatLongDistanceKeyMaker_swiginit, METH_VARARGS, NULL},
	 { "Database_add_database", _wrap_Database_add_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add shards from another Database.\n"
		"\n"
		"void Xapian::Database::add_database(const Database &other)\n"
		"Xapian::Database::add_database Any shards in other are appended to the\n"
		"list of shards in this object. The shards are reference counted and\n"
		"also remain in other.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"other:  Another Database to add shards from\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  if other is the same object as this. \n"
		""},
	 { "Database_size", _wrap_Database_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of shards in this Database object.\n"
		"\n"
		"size_t Xapian::Database::size() const Xapian::Database::size If you\n"
		"want the number of documents, see @ get_doccount().\n"
		"\n"
		"Xapian 1.4.12 \n"
		""},
	 { "new_Database", _wrap_new_Database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Move constructor.\n"
		"\n"
		"Xapian::Database::Database(Database &&o) Xapian::Database::Database\n"
		""},
	 { "delete_Database", _wrap_delete_Database, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::Database::~Database() Xapian::Database::~Database\n"
		""},
	 { "Database_reopen", _wrap_Database_reopen, METH_O, "\n"
		"\n"
		"\n"
		"Reopen the database at the latest available revision.\n"
		"\n"
		"bool Xapian::Database::reopen() Xapian::Database::reopen  Xapian\n"
		"databases (at least with most backends) support versioning such that a\n"
		"Database object uses a snapshot of the database. However, write\n"
		"operations may cause this snapshot to be discarded, which can cause\n"
		"Xapian::DatabaseModifiedError to be thrown. You can recover from this\n"
		"situation by calling reopen() and restarting the search operation.\n"
		"\n"
		"All shards are updated to the latest available revision. This should\n"
		"be a cheap operation if they're already at the latest revision, so if\n"
		"you're using the same Database object for many searches it's\n"
		"reasonable to call reopen() before each search.\n"
		"\n"
		"true if one or more shards have moved to a newer revision (if false is\n"
		"returned then it's definitely the case that no shards were reopened,\n"
		"which applications may find useful when caching results, etc). In\n"
		"Xapian < 1.3.0, this method did not return a value.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::DatabaseError:  is thrown if close() has been called on any of\n"
		"the shards. \n"
		""},
	 { "Database_close", _wrap_Database_close, METH_O, "\n"
		"\n"
		"\n"
		"Close the database.\n"
		"\n"
		"void Xapian::Database::close() Xapian::Database::close This closes the\n"
		"database and closes all its file handles.\n"
		"\n"
		"For a WritableDatabase, if a transaction is active it will be aborted,\n"
		"while if no transaction is active commit() will be implicitly called.\n"
		"Also the write lock is released.\n"
		"\n"
		"Calling close() on an object cannot be undone - in particular, a\n"
		"subsequent call to reopen() on the same object will not reopen it, but\n"
		"will instead throw a Xapian::DatabaseClosedError exception.\n"
		"\n"
		"Calling close() again on an object which has already been closed has\n"
		"no effect (and doesn't raise an exception).\n"
		"\n"
		"After close() has been called, calls to other methods of the database,\n"
		"and to methods of other objects associated with the database, will\n"
		"either:\n"
		"\n"
		"behave exactly as they would have done if the database had not been\n"
		"closed (this can only happen if all the required data is cached)\n"
		"\n"
		"raise a Xapian::DatabaseClosedError exception.\n"
		"\n"
		"The reason for this behaviour is that otherwise we'd have to check\n"
		"that the database is still open on every method call on every object\n"
		"associated with a Database, when in many cases they are working on\n"
		"data which has already been loaded and so they are able to just behave\n"
		"correctly.\n"
		"\n"
		"This method was added in Xapian 1.1.0. \n"
		""},
	 { "Database___str__", _wrap_Database___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::Database::get_description() const\n"
		"Xapian::Database::get_description\n"
		""},
	 { "Database__postlist_begin", _wrap_Database__postlist_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating the postings of a term.\n"
		"\n"
		"PostingIterator Xapian::Database::postlist_begin(std::string_view\n"
		"term) const Xapian::Database::postlist_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to iterate the postings of. An empty string acts as a\n"
		"special pseudo-term which indexes all the documents in the database\n"
		"with a wdf of 1. \n"
		""},
	 { "Database__postlist_end", _wrap_Database__postlist_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to postlist_begin().\n"
		"\n"
		"PostingIterator Xapian::Database::postlist_end(std::string_view) const\n"
		"noexcept Xapian::Database::postlist_end\n"
		""},
	 { "Database__termlist_begin", _wrap_Database__termlist_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating the terms in a document.\n"
		"\n"
		"TermIterator Xapian::Database::termlist_begin(Xapian::docid did) const\n"
		"Xapian::Database::termlist_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to iterate terms from\n"
		"\n"
		"The terms are returned in ascending string order (by byte value). \n"
		""},
	 { "Database__termlist_end", _wrap_Database__termlist_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to termlist_begin().\n"
		"\n"
		"TermIterator Xapian::Database::termlist_end(Xapian::docid) const\n"
		"noexcept Xapian::Database::termlist_end\n"
		""},
	 { "Database_has_positions", _wrap_Database_has_positions, METH_O, "\n"
		"\n"
		"\n"
		"Does this database have any positional information?\n"
		"\n"
		"bool Xapian::Database::has_positions() const\n"
		"Xapian::Database::has_positions\n"
		""},
	 { "Database__positionlist_begin", _wrap_Database__positionlist_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating positions for a term in a document.\n"
		"\n"
		"PositionIterator Xapian::Database::positionlist_begin(Xapian::docid\n"
		"did, std::string_view term) const Xapian::Database::positionlist_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"term:  The term\n"
		"\n"
		"1.1.0 If the specified document doesn't exist or the specified term\n"
		"doesn't exist in the specified document, then a valid iterator is\n"
		"still returned, but it will be equal to positionlist_end(). \n"
		""},
	 { "Database__positionlist_end", _wrap_Database__positionlist_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to positionlist_begin().\n"
		"\n"
		"PositionIterator Xapian::Database::positionlist_end(Xapian::docid,\n"
		"std::string_view) const noexcept Xapian::Database::positionlist_end\n"
		""},
	 { "Database__allterms_begin", _wrap_Database__allterms_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating all terms in the database with a given prefix.\n"
		"\n"
		"TermIterator Xapian::Database::allterms_begin(std::string_view\n"
		"prefix={}) const Xapian::Database::allterms_begin The terms are\n"
		"returned in ascending string order (by byte value).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix:  The prefix to restrict the returned terms to (default:\n"
		"iterate all terms) \n"
		""},
	 { "Database__allterms_end", _wrap_Database__allterms_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to allterms_begin(prefix).\n"
		"\n"
		"TermIterator Xapian::Database::allterms_end(std::string_view={}) const\n"
		"noexcept Xapian::Database::allterms_end\n"
		""},
	 { "Database_get_doccount", _wrap_Database_get_doccount, METH_O, "\n"
		"\n"
		"\n"
		"Get the number of documents in the database.\n"
		"\n"
		"Xapian::doccount Xapian::Database::get_doccount() const\n"
		"Xapian::Database::get_doccount\n"
		""},
	 { "Database_get_lastdocid", _wrap_Database_get_lastdocid, METH_O, "\n"
		"\n"
		"\n"
		"Get the highest document id which has been used in the database.\n"
		"\n"
		"Xapian::docid Xapian::Database::get_lastdocid() const\n"
		"Xapian::Database::get_lastdocid\n"
		""},
	 { "Database_get_average_length", _wrap_Database_get_average_length, METH_O, "\n"
		"\n"
		"\n"
		"Get the mean document length in the database.\n"
		"\n"
		"double Xapian::Database::get_average_length() const\n"
		"Xapian::Database::get_average_length\n"
		""},
	 { "Database_get_avlength", _wrap_Database_get_avlength, METH_O, "\n"
		"\n"
		"\n"
		"Old name for get_average_length() for backward compatibility.\n"
		"\n"
		"double Xapian::Database::get_avlength() const\n"
		"Xapian::Database::get_avlength\n"
		""},
	 { "Database_get_total_length", _wrap_Database_get_total_length, METH_O, "\n"
		"\n"
		"\n"
		"Get the total length of all the documents in the database.\n"
		"\n"
		"Xapian::totallength Xapian::Database::get_total_length() const\n"
		"Xapian::Database::get_total_length\n"
		"\n"
		"Added in Xapian 1.4.5. \n"
		""},
	 { "Database_get_termfreq", _wrap_Database_get_termfreq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the number of documents indexed by a specified term.\n"
		"\n"
		"Xapian::doccount Xapian::Database::get_termfreq(std::string_view term)\n"
		"const Xapian::Database::get_termfreq\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to get the frequency of. An empty string acts as a\n"
		"special pseudo-term which indexes all the documents in the database,\n"
		"so returns get_doccount(). If the term isn't present in the database,\n"
		"0 is returned. \n"
		""},
	 { "Database_term_exists", _wrap_Database_term_exists, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Test is a particular term is present in any document.\n"
		"\n"
		"bool Xapian::Database::term_exists(std::string_view term) const\n"
		"Xapian::Database::term_exists\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to test for. An empty string acts as a special pseudo-\n"
		"term which indexes all the documents in the database, so returns true\n"
		"if the database contains any documents.\n"
		"\n"
		"db.term_exists(t) gives the same answer as db.get_termfreq(t) != 0,\n"
		"but is typically more efficient. \n"
		""},
	 { "Database_get_collection_freq", _wrap_Database_get_collection_freq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the total number of occurrences of a specified term.\n"
		"\n"
		"Xapian::termcount\n"
		"Xapian::Database::get_collection_freq(std::string_view term) const\n"
		"Xapian::Database::get_collection_freq The collection frequency of a\n"
		"term is defined as the total number of times it occurs in the\n"
		"database, which is the sum of its wdf in all the documents it indexes.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to get the collection frequency of. An empty string\n"
		"acts as a special pseudo-term which indexes all the documents in the\n"
		"database, so returns get_doccount(). If the term isn't present in the\n"
		"database, 0 is returned. \n"
		""},
	 { "Database_get_value_freq", _wrap_Database_get_value_freq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return the frequency of a given value slot.\n"
		"\n"
		"Xapian::doccount Xapian::Database::get_value_freq(Xapian::valueno\n"
		"slot) const Xapian::Database::get_value_freq This is the number of\n"
		"documents which have a (non-empty) value stored in the slot.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to examine. \n"
		""},
	 { "Database_get_value_lower_bound", _wrap_Database_get_value_lower_bound, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a lower bound on the values stored in the given value slot.\n"
		"\n"
		"std::string Xapian::Database::get_value_lower_bound(Xapian::valueno\n"
		"slot) const Xapian::Database::get_value_lower_bound If there are no\n"
		"values stored in the given value slot, this will return an empty\n"
		"string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to examine. \n"
		""},
	 { "Database_get_value_upper_bound", _wrap_Database_get_value_upper_bound, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get an upper bound on the values stored in the given value slot.\n"
		"\n"
		"std::string Xapian::Database::get_value_upper_bound(Xapian::valueno\n"
		"slot) const Xapian::Database::get_value_upper_bound If there are no\n"
		"values stored in the given value slot, this will return an empty\n"
		"string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to examine. \n"
		""},
	 { "Database_get_doclength_lower_bound", _wrap_Database_get_doclength_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get a lower bound on the length of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_doclength_lower_bound() const\n"
		"Xapian::Database::get_doclength_lower_bound This bound does not\n"
		"include any zero-length documents. \n"
		""},
	 { "Database_get_doclength_upper_bound", _wrap_Database_get_doclength_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get an upper bound on the length of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_doclength_upper_bound() const\n"
		"Xapian::Database::get_doclength_upper_bound\n"
		""},
	 { "Database_get_wdf_upper_bound", _wrap_Database_get_wdf_upper_bound, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get an upper bound on the wdf of term term.\n"
		"\n"
		"Xapian::termcount\n"
		"Xapian::Database::get_wdf_upper_bound(std::string_view term) const\n"
		"Xapian::Database::get_wdf_upper_bound\n"
		""},
	 { "Database_get_unique_terms_lower_bound", _wrap_Database_get_unique_terms_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get a lower bound on the unique terms size of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_unique_terms_lower_bound()\n"
		"const Xapian::Database::get_unique_terms_lower_bound\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_get_unique_terms_upper_bound", _wrap_Database_get_unique_terms_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get an upper bound on the unique terms size of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_unique_terms_upper_bound()\n"
		"const Xapian::Database::get_unique_terms_upper_bound\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_valuestream_begin", _wrap_Database_valuestream_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return an iterator over the value in slot slot for each document.\n"
		"\n"
		"ValueIterator Xapian::Database::valuestream_begin(Xapian::valueno\n"
		"slot) const Xapian::Database::valuestream_begin\n"
		""},
	 { "Database_valuestream_end", _wrap_Database_valuestream_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return end iterator corresponding to valuestream_begin().\n"
		"\n"
		"ValueIterator Xapian::Database::valuestream_end(Xapian::valueno) const\n"
		"noexcept Xapian::Database::valuestream_end\n"
		""},
	 { "Database_get_doclength", _wrap_Database_get_doclength, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the length of a specified document.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_doclength(Xapian::docid did)\n"
		"const Xapian::Database::get_doclength\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"Xapian defines a document's length as the sum of the wdf of all the\n"
		"terms which index it. \n"
		""},
	 { "Database_get_unique_terms", _wrap_Database_get_unique_terms, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the number of unique terms in a specified document.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_unique_terms(Xapian::docid\n"
		"did) const Xapian::Database::get_unique_terms\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"This is the number of different terms which index the given document.\n"
		"\n"
		""},
	 { "Database_get_wdfdocmax", _wrap_Database_get_wdfdocmax, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the maximum wdf value in a specified document.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_wdfdocmax(Xapian::docid did)\n"
		"const Xapian::Database::get_wdfdocmax\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_keep_alive", _wrap_Database_keep_alive, METH_O, "\n"
		"\n"
		"\n"
		"Send a keep-alive message.\n"
		"\n"
		"void Xapian::Database::keep_alive() Xapian::Database::keep_alive For\n"
		"remote databases, this method sends a message to the server to reset\n"
		"the timeout timer. As well as preventing timeouts at the Xapian remote\n"
		"protocol level, this message will also avoid timeouts at lower levels.\n"
		"\n"
		"For local databases, this method does nothing. \n"
		""},
	 { "Database_get_document", _wrap_Database_get_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a document from the database.\n"
		"\n"
		"Xapian::Document Xapian::Database::get_document(Xapian::docid did,\n"
		"unsigned flags=0) const Xapian::Database::get_document The returned\n"
		"object acts as a handle which lazily fetches information about the\n"
		"specified document from the database.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document ID of the document to be get\n"
		"\n"
		"flags:  Zero or more flags bitwise-or-ed together (currently only\n"
		"Xapian::DOC_ASSUME_VALID is supported). (default: 0)\n"
		"\n"
		"The flags parameter was added in Xapian 2.0.0.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  is thrown if did is 0.\n"
		"\n"
		"Xapian::DocNotFoundError:  is thrown if the specified docid is not\n"
		"present in this database. \n"
		""},
	 { "Database_get_spelling_suggestion", _wrap_Database_get_spelling_suggestion, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Suggest a spelling correction.\n"
		"\n"
		"std::string Xapian::Database::get_spelling_suggestion(std::string_view\n"
		"word, unsigned max_edit_distance=2) const\n"
		"Xapian::Database::get_spelling_suggestion\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"word:  The potentially misspelled word.\n"
		"\n"
		"max_edit_distance:  Only consider words which are at most\n"
		"max_edit_distance edits from word. An edit is a character insertion,\n"
		"deletion, or the transposition of two adjacent characters (default is\n"
		"2). \n"
		""},
	 { "Database__spellings_begin", _wrap_Database__spellings_begin, METH_O, "\n"
		"\n"
		"\n"
		"An iterator which returns all the spelling correction targets.\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::spellings_begin() const\n"
		"Xapian::Database::spellings_begin This returns all the words which are\n"
		"considered as targets for the spelling correction algorithm. The\n"
		"frequency of each word is available as the term frequency of each\n"
		"entry in the returned iterator. \n"
		""},
	 { "Database__spellings_end", _wrap_Database__spellings_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to spellings_begin().\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::spellings_end() const noexcept\n"
		"Xapian::Database::spellings_end\n"
		""},
	 { "Database__synonyms_begin", _wrap_Database__synonyms_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An iterator which returns all the synonyms for a given term.\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::synonyms_begin(std::string_view\n"
		"term) const Xapian::Database::synonyms_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to return synonyms for. \n"
		""},
	 { "Database__synonyms_end", _wrap_Database__synonyms_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to synonyms_begin(term).\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::synonyms_end(std::string_view)\n"
		"const noexcept Xapian::Database::synonyms_end\n"
		""},
	 { "Database__synonym_keys_begin", _wrap_Database__synonym_keys_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An iterator which returns all terms which have synonyms.\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::synonym_keys_begin(std::string_view prefix={}) const\n"
		"Xapian::Database::synonym_keys_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix:  If non-empty, only terms with this prefix are returned. \n"
		""},
	 { "Database__synonym_keys_end", _wrap_Database__synonym_keys_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to synonym_keys_begin(prefix).\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::synonym_keys_end(std::string_view={}) const noexcept\n"
		"Xapian::Database::synonym_keys_end\n"
		""},
	 { "Database_get_metadata", _wrap_Database_get_metadata, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the user-specified metadata associated with a given key.\n"
		"\n"
		"std::string Xapian::Database::get_metadata(std::string_view key) const\n"
		"Xapian::Database::get_metadata User-specified metadata allows you to\n"
		"store arbitrary information in the form of (key, value) pairs. See\n"
		"WritableDatabase::set_metadata() for more information.\n"
		"\n"
		"When invoked on a Xapian::Database object representing multiple\n"
		"databases, currently only the metadata for the first is considered but\n"
		"this behaviour may change in the future.\n"
		"\n"
		"If there is no piece of metadata associated with the specified key, an\n"
		"empty string is returned (this applies even for backends which don't\n"
		"support metadata).\n"
		"\n"
		"Empty keys are not valid, and specifying one will cause an exception.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The key of the metadata item to access.\n"
		"\n"
		"The retrieved metadata item's value.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  will be thrown if the key supplied is\n"
		"empty. \n"
		""},
	 { "Database__metadata_keys_begin", _wrap_Database__metadata_keys_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An iterator which returns all user-specified metadata keys.\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::metadata_keys_begin(std::string_view prefix={})\n"
		"const Xapian::Database::metadata_keys_begin When invoked on a\n"
		"Xapian::Database object representing multiple databases, currently\n"
		"only the metadata for the first is considered but this behaviour may\n"
		"change in the future.\n"
		"\n"
		"If the backend doesn't support metadata, then this method returns an\n"
		"iterator which compares equal to that returned by metadata_keys_end().\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix:  If non-empty, only keys with this prefix are returned.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  will be thrown if the backend implements\n"
		"user-specified metadata, but doesn't implement iterating its keys\n"
		"(currently this happens for the InMemory backend). \n"
		""},
	 { "Database__metadata_keys_end", _wrap_Database__metadata_keys_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to metadata_keys_begin().\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::metadata_keys_end(std::string_view={}) const\n"
		"noexcept Xapian::Database::metadata_keys_end\n"
		""},
	 { "Database_get_uuid", _wrap_Database_get_uuid, METH_O, "\n"
		"\n"
		"\n"
		"Get the UUID for the database.\n"
		"\n"
		"std::string Xapian::Database::get_uuid() const\n"
		"Xapian::Database::get_uuid The UUID will persist for the lifetime of\n"
		"the database.\n"
		"\n"
		"Replicas (eg, made with the replication protocol, or by copying all\n"
		"the database files) will have the same UUID. However, copies (made\n"
		"with copydatabase, or xapian-compact) will have different UUIDs.\n"
		"\n"
		"If the backend does not support UUIDs or this database has no\n"
		"subdatabases, the UUID will be empty.\n"
		"\n"
		"If this database has multiple sub-databases, the UUID string will\n"
		"contain the UUIDs of all the sub-databases separated by colons. \n"
		""},
	 { "Database_locked", _wrap_Database_locked, METH_O, "\n"
		"\n"
		"\n"
		"Test if this database is currently locked for writing.\n"
		"\n"
		"bool Xapian::Database::locked() const Xapian::Database::locked If the\n"
		"underlying object is actually a WritableDatabase, always returns true\n"
		"unless close() has been called.\n"
		"\n"
		"Otherwise tests if there's a writer holding the lock (or if we can't\n"
		"test for a lock without taking it on the current platform, throw\n"
		"Xapian::UnimplementedError). If there's an error while trying to test\n"
		"the lock, throws Xapian::DatabaseLockError.\n"
		"\n"
		"For multi-databases, this tests each sub-database and returns true if\n"
		"any of them are locked. \n"
		""},
	 { "Database_lock", _wrap_Database_lock, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Lock a read-only database for writing.\n"
		"\n"
		"Xapian::WritableDatabase Xapian::Database::lock(int flags=0)\n"
		"Xapian::Database::lock If the database is actually already writable\n"
		"(i.e. a WritableDatabase via a Database reference) then the same\n"
		"database is returned (with its flags updated, so this provides an\n"
		"efficient way to modify flags on an open WritableDatabase).\n"
		"\n"
		"Unlike unlock(), the object this is called on remains open.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"flags:  The flags to use for the writable database. Flags which\n"
		"specify how to open the database are ignored (e.g.\n"
		"DB_CREATE_OR_OVERWRITE doesn't result in the database being wiped),\n"
		"and flags which specify the backend are also ignored as they are only\n"
		"relevant when creating a new database.\n"
		"\n"
		"A WritableDatabase object open on the same database.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_unlock", _wrap_Database_unlock, METH_O, "\n"
		"\n"
		"\n"
		"Release a database write lock.\n"
		"\n"
		"Xapian::Database Xapian::Database::unlock() Xapian::Database::unlock\n"
		"If called on a read-only database then the same database is returned.\n"
		"\n"
		"If called on a writable database, the object this method was called on\n"
		"is closed.\n"
		"\n"
		"A Database object open on the same database.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_get_revision", _wrap_Database_get_revision, METH_O, "\n"
		"\n"
		"\n"
		"Get the revision of the database.\n"
		"\n"
		"Xapian::rev Xapian::Database::get_revision() const\n"
		"Xapian::Database::get_revision The revision is an unsigned integer\n"
		"which increases with each commit. In practice it typically increments\n"
		"by one for each revision but you should not rely on that.\n"
		"\n"
		"Xapian 1.4.13 and later return 0 for a database consisting of no\n"
		"shards.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidOperationError:  If the database consists of more than\n"
		"one shard. In Xapian < 1.4.13, this is also thrown if the database\n"
		"consists of no shards.\n"
		"\n"
		"Xapian::UnimplementedError:  Currently this is only implemented for\n"
		"glass (and for chert in Xapian 1.4.x). \n"
		""},
	 { "Database_check", _wrap_Database_check, METH_VARARGS, NULL},
	 { "Database_compact", _wrap_Database_compact, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Produce a compact version of this database.\n"
		"\n"
		"void Xapian::Database::compact(int fd, unsigned flags, int block_size,\n"
		"Xapian::Compactor &compactor) Xapian::Database::compact The compactor\n"
		"functor allows handling progress output and specifying how user\n"
		"metadata is merged.\n"
		"\n"
		"This variant writes a single-file database to the specified file\n"
		"descriptor. Only the glass backend supports such databases, so this\n"
		"form is only supported for this backend.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"fd:  File descriptor to write the compact version to. The descriptor\n"
		"needs to be readable and writable (open with O_RDWR) and seekable. The\n"
		"current file offset is used, allowing compacting to a single file\n"
		"database embedded within another file. Xapian takes ownership of the\n"
		"file descriptor and will close it before returning.\n"
		"\n"
		"flags:  Any of the following combined using bitwise-or (| in C++):\n"
		"Xapian::DBCOMPACT_NO_RENUMBER By default the document ids will be\n"
		"renumbered the output - currently by applying the same offset to all\n"
		"the document ids in a particular source database. If this flag is\n"
		"specified, then this renumbering doesn't happen, but all the document\n"
		"ids must be unique over all source databases. Currently the ranges of\n"
		"document ids in each source must not overlap either, though this\n"
		"restriction may be removed in the future.\n"
		"\n"
		"Xapian::DBCOMPACT_MULTIPASS If merging more than 3 databases, merge\n"
		"the postlists in multiple passes, which is generally faster but\n"
		"requires more disk space for temporary files.\n"
		"\n"
		"Xapian::DBCOMPACT_SINGLE_FILE Produce a single-file database (only\n"
		"supported for glass currently).\n"
		"\n"
		"At most one of:  Xapian::Compactor::STANDARD - Don't split items\n"
		"unnecessarily.\n"
		"\n"
		"Xapian::Compactor::FULL - Split items whenever it saves space (the\n"
		"default).\n"
		"\n"
		"Xapian::Compactor::FULLER - Allow oversize items to save more space\n"
		"(not recommended if you ever plan to update the compacted database).\n"
		"\n"
		"1.4.31 Has the same effect as FULL.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"block_size:  This specifies the block size (in bytes) for to use for\n"
		"the output. For glass, the block size must be a power of 2 between\n"
		"2048 and 65536 (inclusive), and the default (also used if an invalid\n"
		"value is passed) is 8192 bytes.\n"
		"\n"
		"compactor:  Functor\n"
		"\n"
		"1.3.4 This method was added to replace various methods of the\n"
		"Compactor class. \n"
		""},
	 { "Database_reconstruct_text", _wrap_Database_reconstruct_text, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Reconstruct document text.\n"
		"\n"
		"std::string Xapian::Database::reconstruct_text(Xapian::docid did,\n"
		"size_t length=0, std::string_view prefix={}, Xapian::termpos\n"
		"start_pos=0, Xapian::termpos end_pos=0) const\n"
		"Xapian::Database::reconstruct_text This uses term positional\n"
		"information to reconstruct the document text which was indexed.\n"
		"Reading the required positional information is potentially quite I/O\n"
		"intensive.\n"
		"\n"
		"The reconstructed text will be missing punctuation and most\n"
		"capitalisation.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document to reconstruct\n"
		"\n"
		"length:  Number of bytes of text to aim for - note that slightly more\n"
		"may be returned (default: 0 meaning unlimited)\n"
		"\n"
		"prefix:  Term prefix to reconstruct (default: none)\n"
		"\n"
		"start_pos:  First position to reconstruct (default: 0)\n"
		"\n"
		"end_pos:  Last position to reconstruct (default: 0 meaning all)\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_swigregister", Database_swigregister, METH_O, NULL},
	 { "Database_swiginit", Database_swiginit, METH_VARARGS, NULL},
	 { "WritableDatabase_add_database", _wrap_WritableDatabase_add_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add shards from another WritableDatabase.\n"
		"\n"
		"void Xapian::WritableDatabase::add_database(const WritableDatabase\n"
		"&other) Xapian::WritableDatabase::add_database Any shards in other are\n"
		"added to the list of shards in this object. The shards are reference\n"
		"counted and also remain in other.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"other:  Another WritableDatabase to add shards from\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  if other is the same object as this. \n"
		""},
	 { "new_WritableDatabase", _wrap_new_WritableDatabase, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Move constructor.\n"
		"\n"
		"Xapian::WritableDatabase::WritableDatabase(WritableDatabase &&o)\n"
		"Xapian::WritableDatabase::WritableDatabase\n"
		""},
	 { "WritableDatabase_commit", _wrap_WritableDatabase_commit, METH_O, "\n"
		"\n"
		"\n"
		"Commit pending modifications.\n"
		"\n"
		"void Xapian::WritableDatabase::commit()\n"
		"Xapian::WritableDatabase::commit Updates to a Xapian database are more\n"
		"efficient when applied in bulk, so by default Xapian stores\n"
		"modifications in memory until a threshold is exceeded and then they\n"
		"are committed to disk.\n"
		"\n"
		"When the database is closed (by an explicit call to close() or its\n"
		"destructor being called) then commit() is implicitly called unless a\n"
		"transaction is active.\n"
		"\n"
		"You can force any such pending modifications to be committed by\n"
		"calling this method, but bear in mind that the batching happens for a\n"
		"reason and calling commit() a lot is likely to slow down indexing.\n"
		"\n"
		"If the commit operation succeeds then the changes are reliably written\n"
		"to disk and available to readers. If the commit operation fails, then\n"
		"any pending modifications are discarded.\n"
		"\n"
		"However, note that if called on a sharded database, atomicity isn't\n"
		"guaranteed between shards - it's possible for the changes to one shard\n"
		"to be committed but changes to another shard to fail.\n"
		"\n"
		"It's not valid to call commit() within a transaction - see\n"
		"begin_transaction() for more details of how transactions work in\n"
		"Xapian.\n"
		"\n"
		"Currently batched modifications are automatically committed every\n"
		"10000 documents added, deleted, or modified. This value is rather\n"
		"conservative, and if you have a machine with plenty of memory, you can\n"
		"improve indexing throughput dramatically by setting\n"
		"XAPIAN_FLUSH_THRESHOLD in the environment to a larger value.\n"
		"\n"
		"This method was new in Xapian 1.1.0 - in earlier versions it was\n"
		"called flush(). \n"
		""},
	 { "WritableDatabase_begin_transaction", _wrap_WritableDatabase_begin_transaction, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Begin a transaction.\n"
		"\n"
		"void Xapian::WritableDatabase::begin_transaction(bool flushed=true)\n"
		"Xapian::WritableDatabase::begin_transaction A Xapian transaction is a\n"
		"set of consecutive modifications to be committed as an atomic unit -\n"
		"in any committed revision of the database either none are present or\n"
		"they all are.\n"
		"\n"
		"However, note that if called on a sharded database, atomicity isn't\n"
		"guaranteed between shards. Within each shard, the transaction will\n"
		"still act atomically.\n"
		"\n"
		"A transaction is started with begin_transaction() and can either be\n"
		"completed by calling commit_transaction() or aborted by calling\n"
		"cancel_transaction().\n"
		"\n"
		"Closing the database (by an explicit call to close() or by its\n"
		"destructor being called) when a transaction is active will implicitly\n"
		"call cancel_transaction() to abort the transaction and discard the\n"
		"changes in it.\n"
		"\n"
		"By default, commit() is implicitly called by begin_transaction() and\n"
		"commit_transaction() so that the changes in the transaction are\n"
		"committed or not independent of changes before or after it.\n"
		"\n"
		"The downside of these implicit calls to commit() is that small\n"
		"transactions can harm indexing performance in the same way that\n"
		"explicitly calling commit() frequently can.\n"
		"\n"
		"If you're applying atomic groups of changes and only wish to ensure\n"
		"that each group is either applied or not applied, then you can prevent\n"
		"the automatic commit() before and after the transaction by starting\n"
		"the transaction with begin_transaction(false). However, if\n"
		"cancel_transaction() is called (or if commit_transaction() isn't\n"
		"called before the WritableDatabase object is destroyed) then any\n"
		"changes which were pending before the transaction began will also be\n"
		"discarded.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"flushed:  Is this a flushed transaction? By default transactions are\n"
		"\"flushed\", which means that committing a transaction will ensure\n"
		"those changes are permanently written to the database. By contrast,\n"
		"unflushed transactions only ensure that changes within the transaction\n"
		"are either all applied or all aren't.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  is thrown if this is an InMemory\n"
		"database, which don't currently support transactions.\n"
		"\n"
		"Xapian::InvalidOperationError:  will be thrown if a transaction is\n"
		"already active. \n"
		""},
	 { "WritableDatabase_commit_transaction", _wrap_WritableDatabase_commit_transaction, METH_O, "\n"
		"\n"
		"\n"
		"Complete the transaction currently in progress.\n"
		"\n"
		"void Xapian::WritableDatabase::commit_transaction()\n"
		"Xapian::WritableDatabase::commit_transaction If the transaction was\n"
		"begun as a flushed transaction then the changes in it have been\n"
		"committed to the database upon successful completion of this method.\n"
		"\n"
		"If an exception is thrown, then the changes in the transaction will be\n"
		"discarded (if the transaction was not begun as a flushed transaction,\n"
		"any changes made but not committed before begin_transaction() will\n"
		"also be discarded).\n"
		"\n"
		"In all cases the transaction will no longer be in progress.\n"
		"\n"
		"Note that if called on a sharded database, atomicity isn't guaranteed\n"
		"between shards. Within each shard, the transaction will still act\n"
		"atomically.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  is thrown if this is an InMemory\n"
		"database, which don't currently support transactions.\n"
		"\n"
		"Xapian::InvalidOperationError:  is thrown if no transaction was\n"
		"active. \n"
		""},
	 { "WritableDatabase_cancel_transaction", _wrap_WritableDatabase_cancel_transaction, METH_O, "\n"
		"\n"
		"\n"
		"Abort the transaction currently in progress.\n"
		"\n"
		"void Xapian::WritableDatabase::cancel_transaction()\n"
		"Xapian::WritableDatabase::cancel_transaction Changes made within the\n"
		"current transaction will be discarded (if the transaction was not\n"
		"begun as a flushed transaction, any changes made but not committed\n"
		"before begin_transaction() will also be discarded).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  is thrown if this is an InMemory\n"
		"database, which don't currently support transactions.\n"
		"\n"
		"Xapian::InvalidOperationError:  is thrown if no transaction was\n"
		"active. \n"
		""},
	 { "WritableDatabase_add_document", _wrap_WritableDatabase_add_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a document to the database.\n"
		"\n"
		"Xapian::docid Xapian::WritableDatabase::add_document(const\n"
		"Xapian::Document &doc) Xapian::WritableDatabase::add_document The\n"
		"document is allocated document ID ( get_lastdocid() + 1) - the next\n"
		"highest document ID which has never previously been used by this\n"
		"database (so docids from deleted documents won't be reused).\n"
		"\n"
		"If you want to specify the document ID to be used, you should call\n"
		"replace_document() instead.\n"
		"\n"
		"If a transaction is active, the document addition is added to the\n"
		"transaction; otherwise it is added to the current batch of changes.\n"
		"Either way, it won't be visible to readers right away (unless we're\n"
		"not in a transaction and the addition triggers an automatic commit).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"doc:  The Document object to be added.\n"
		"\n"
		"The document ID allocated to the document. \n"
		""},
	 { "WritableDatabase_delete_document", _wrap_WritableDatabase_delete_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Delete any documents indexed by a term from the database.\n"
		"\n"
		"void Xapian::WritableDatabase::delete_document(std::string_view\n"
		"unique_term) Xapian::WritableDatabase::delete_document This method\n"
		"removes any documents indexed by the specified term from the database.\n"
		"\n"
		"A major use is for convenience when UIDs from another system are\n"
		"mapped to terms in Xapian, although this method has other uses (for\n"
		"example, you could add a \"deletion date\" term to documents at index\n"
		"time and use this method to delete all documents due for deletion on a\n"
		"particular date).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"unique_term:  The term to remove references to.\n"
		"\n"
		"2.0.0 The changes made by this method are made atomically. Previously\n"
		"automatic commits could happen during the batch. \n"
		""},
	 { "WritableDatabase_replace_document", _wrap_WritableDatabase_replace_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Replace any documents matching a term.\n"
		"\n"
		"Xapian::docid\n"
		"Xapian::WritableDatabase::replace_document(std::string_view\n"
		"unique_term, const Xapian::Document &document)\n"
		"Xapian::WritableDatabase::replace_document This method replaces any\n"
		"documents indexed by the specified term with the specified document.\n"
		"If any documents are indexed by the term, the lowest document ID will\n"
		"be used for the document, otherwise a new document ID will be\n"
		"generated as for add_document.\n"
		"\n"
		"One common use is to allow UIDs from another system to easily be\n"
		"mapped to terms in Xapian. Note that this method doesn't automatically\n"
		"add unique_term as a term, so you'll need to call\n"
		"document.add_term(unique_term) first when using replace_document() in\n"
		"this way.\n"
		"\n"
		"Note that changes to the database won't be immediately committed to\n"
		"disk; see commit() for more details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"unique_term:  The \"unique\" term.\n"
		"\n"
		"document:  The new document.\n"
		"\n"
		"The document ID used by the new document. If term existed in the\n"
		"database, this will be the first document ID that was indexed by that\n"
		"term; otherwise the database allocates ( get_lastdocid() + 1) as it\n"
		"does for add_document().\n"
		"\n"
		"2.0.0 The changes made by this method are made atomically. Previously\n"
		"automatic commits could happen during the batch. \n"
		""},
	 { "WritableDatabase_add_spelling", _wrap_WritableDatabase_add_spelling, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a word to the spelling dictionary.\n"
		"\n"
		"void Xapian::WritableDatabase::add_spelling(std::string_view word,\n"
		"Xapian::termcount freqinc=1) const\n"
		"Xapian::WritableDatabase::add_spelling If the word is already present,\n"
		"its frequency is increased.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"word:  The word to add.\n"
		"\n"
		"freqinc:  How much to increase its frequency by (default 1). \n"
		""},
	 { "WritableDatabase_remove_spelling", _wrap_WritableDatabase_remove_spelling, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a word from the spelling dictionary.\n"
		"\n"
		"termcount Xapian::WritableDatabase::remove_spelling(std::string_view\n"
		"word, termcount freqdec=1) const\n"
		"Xapian::WritableDatabase::remove_spelling The word's frequency is\n"
		"decreased, and if would become zero or less then the word is removed\n"
		"completely.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"word:  The word to remove.\n"
		"\n"
		"freqdec:  How much to decrease its frequency by (default 1).\n"
		"\n"
		"Any \"unused\" freqdec (if the word's frequency was less than freqdec\n"
		"then the difference is returned, else 0 is returned). Prior to 2.0.0\n"
		"this method had void return type. \n"
		""},
	 { "WritableDatabase_add_synonym", _wrap_WritableDatabase_add_synonym, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a synonym for a term.\n"
		"\n"
		"void Xapian::WritableDatabase::add_synonym(std::string_view term,\n"
		"std::string_view synonym) const Xapian::WritableDatabase::add_synonym\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to add a synonym for.\n"
		"\n"
		"synonym:  The synonym to add. If this is already a synonym for term,\n"
		"then no action is taken. \n"
		""},
	 { "WritableDatabase_remove_synonym", _wrap_WritableDatabase_remove_synonym, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a synonym for a term.\n"
		"\n"
		"void Xapian::WritableDatabase::remove_synonym(std::string_view term,\n"
		"std::string_view synonym) const\n"
		"Xapian::WritableDatabase::remove_synonym\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to remove a synonym for.\n"
		"\n"
		"synonym:  The synonym to remove. If this isn't currently a synonym for\n"
		"term, then no action is taken. \n"
		""},
	 { "WritableDatabase_clear_synonyms", _wrap_WritableDatabase_clear_synonyms, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove all synonyms for a term.\n"
		"\n"
		"void Xapian::WritableDatabase::clear_synonyms(std::string_view term)\n"
		"const Xapian::WritableDatabase::clear_synonyms\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to remove all synonyms for. If the term has no\n"
		"synonyms, no action is taken. \n"
		""},
	 { "WritableDatabase_set_metadata", _wrap_WritableDatabase_set_metadata, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the user-specified metadata associated with a given key.\n"
		"\n"
		"void Xapian::WritableDatabase::set_metadata(std::string_view key,\n"
		"std::string_view metadata) Xapian::WritableDatabase::set_metadata This\n"
		"method sets the metadata value associated with a given key. If there\n"
		"is already a metadata value stored in the database with the same key,\n"
		"the old value is replaced. If you want to delete an existing item of\n"
		"metadata, just set its value to the empty string.\n"
		"\n"
		"User-specified metadata allows you to store arbitrary information in\n"
		"the form of (key, value) pairs.\n"
		"\n"
		"There's no hard limit on the number of metadata items, or the size of\n"
		"the metadata values. Metadata keys have a limited length, which depend\n"
		"on the backend. We recommend limiting them to 200 bytes. Empty keys\n"
		"are not valid, and specifying one will cause an exception.\n"
		"\n"
		"Metadata modifications are committed to disk in the same way as\n"
		"modifications to the documents in the database are: i.e.,\n"
		"modifications are atomic, and won't be committed to disk immediately\n"
		"(see commit() for more details). This allows metadata to be used to\n"
		"link databases with versioned external resources by storing the\n"
		"appropriate version number in a metadata item.\n"
		"\n"
		"You can also use the metadata to store arbitrary extra information\n"
		"associated with terms, documents, or postings by encoding the termname\n"
		"and/or document id into the metadata key.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The key of the metadata item to set.\n"
		"\n"
		"metadata:  The value of the metadata item to set.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::DatabaseError:  will be thrown if a problem occurs while\n"
		"writing to the database.\n"
		"\n"
		"Xapian::DatabaseCorruptError:  will be thrown if the database is in a\n"
		"corrupt state.\n"
		"\n"
		"Xapian::InvalidArgumentError:  will be thrown if the key supplied is\n"
		"empty.\n"
		"\n"
		"Xapian::UnimplementedError:  will be thrown if the database backend in\n"
		"use doesn't support user- specified metadata. \n"
		""},
	 { "delete_WritableDatabase", _wrap_delete_WritableDatabase, METH_O, NULL},
	 { "WritableDatabase_swigregister", WritableDatabase_swigregister, METH_O, NULL},
	 { "WritableDatabase_swiginit", WritableDatabase_swiginit, METH_VARARGS, NULL},
	 { "remote_open", _wrap_remote_open, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a Database object for read-only access to a remote database\n"
		"accessed via a program.\n"
		"\n"
		"Database Xapian::Remote::open(std::string_view program,\n"
		"std::string_view args, unsigned timeout=10000) Xapian::Remote::open\n"
		"Access to the remote database is done by running an external program\n"
		"and communicating with it on stdin/stdout.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"program:  the external program to run.\n"
		"\n"
		"args:  space-separated list of arguments to pass to program.\n"
		"\n"
		"timeout:  timeout in milliseconds. If this timeout is exceeded for any\n"
		"individual operation on the remote database then\n"
		"Xapian::NetworkTimeoutError is thrown. A timeout of 0 means don't\n"
		"timeout. (Default is 10000ms, which is 10 seconds). \n"
		""},
	 { "remote_open_writable", _wrap_remote_open_writable, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a WritableDatabase object for update access to a remote\n"
		"database accessed via a program.\n"
		"\n"
		"WritableDatabase Xapian::Remote::open_writable(std::string_view\n"
		"program, std::string_view args, unsigned timeout=0, int flags=0)\n"
		"Xapian::Remote::open_writable Access to the remote database is done by\n"
		"running an external program and communicating with it on stdin/stdout.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"program:  the external program to run.\n"
		"\n"
		"args:  space-separated list of arguments to pass to program.\n"
		"\n"
		"timeout:  timeout in milliseconds. If this timeout is exceeded for any\n"
		"individual operation on the remote database then\n"
		"Xapian::NetworkTimeoutError is thrown. (Default is 0, which means\n"
		"don't timeout).\n"
		"\n"
		"flags:   Xapian::DB_RETRY_LOCK or 0. \n"
		""},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "Error_get_type", _wrap_Error_get_type, METH_O, "\n"
		"\n"
		"\n"
		"The type of this error (e.g. \"DocNotFoundError\".).\n"
		"\n"
		"const char * Xapian::Error::get_type() const noexcept\n"
		"Xapian::Error::get_type\n"
		""},
	 { "Error_get_msg", _wrap_Error_get_msg, METH_O, "\n"
		"\n"
		"\n"
		"Message giving details of the error, intended for human consumption.\n"
		"\n"
		"const std::string & Xapian::Error::get_msg() const noexcept\n"
		"Xapian::Error::get_msg\n"
		""},
	 { "Error_get_context", _wrap_Error_get_context, METH_O, "\n"
		"\n"
		"\n"
		"Optional context information.\n"
		"\n"
		"const std::string & Xapian::Error::get_context() const noexcept\n"
		"Xapian::Error::get_context This context is intended for machine use\n"
		"(for example to know which remote server an error came from), but it\n"
		"is typically a plain-text string, and so also fit for human\n"
		"consumption. \n"
		""},
	 { "Error_get_error_string", _wrap_Error_get_error_string, METH_O, "\n"
		"\n"
		"\n"
		"Returns any system error string associated with this exception.\n"
		"\n"
		"const char * Xapian::Error::get_error_string() const\n"
		"Xapian::Error::get_error_string The system error string may come from\n"
		"errno, h_errno (on UNIX), or GetLastError() (on MS Windows). If there\n"
		"is no associated system error string, NULL is returned. \n"
		""},
	 { "Error___str__", _wrap_Error___str__, METH_O, NULL},
	 { "delete_Error", _wrap_delete_Error, METH_O, NULL},
	 { "Error_swigregister", Error_swigregister, METH_O, NULL},
	 { "delete_LogicError", _wrap_delete_LogicError, METH_O, NULL},
	 { "LogicError_swigregister", LogicError_swigregister, METH_O, NULL},
	 { "delete_RuntimeError", _wrap_delete_RuntimeError, METH_O, NULL},
	 { "RuntimeError_swigregister", RuntimeError_swigregister, METH_O, NULL},
	 { "new_AssertionError", _wrap_new_AssertionError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::AssertionError::AssertionError(std::string_view msg_, int\n"
		"errno_) Xapian::AssertionError::AssertionError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_AssertionError", _wrap_delete_AssertionError, METH_O, NULL},
	 { "AssertionError_swigregister", AssertionError_swigregister, METH_O, NULL},
	 { "AssertionError_swiginit", AssertionError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidArgumentError", _wrap_new_InvalidArgumentError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::InvalidArgumentError::InvalidArgumentError(std::string_view\n"
		"msg_, int errno_) Xapian::InvalidArgumentError::InvalidArgumentError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_InvalidArgumentError", _wrap_delete_InvalidArgumentError, METH_O, NULL},
	 { "InvalidArgumentError_swigregister", InvalidArgumentError_swigregister, METH_O, NULL},
	 { "InvalidArgumentError_swiginit", InvalidArgumentError_swiginit, METH_VARARGS, NULL},
	 { "new_InvalidOperationError", _wrap_new_InvalidOperationError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::InvalidOperationError::InvalidOperationError(std::string_view\n"
		"msg_, int errno_) Xapian::InvalidOperationError::InvalidOperationError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_InvalidOperationError", _wrap_delete_InvalidOperationError, METH_O, NULL},
	 { "InvalidOperationError_swigregister", InvalidOperationError_swigregister, METH_O, NULL},
	 { "InvalidOperationError_swiginit", InvalidOperationError_swiginit, METH_VARARGS, NULL},
	 { "new_UnimplementedError", _wrap_new_UnimplementedError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::UnimplementedError::UnimplementedError(std::string_view msg_,\n"
		"int errno_) Xapian::UnimplementedError::UnimplementedError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_UnimplementedError", _wrap_delete_UnimplementedError, METH_O, NULL},
	 { "UnimplementedError_swigregister", UnimplementedError_swigregister, METH_O, NULL},
	 { "UnimplementedError_swiginit", UnimplementedError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseError", _wrap_new_DatabaseError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseError::DatabaseError(std::string_view msg_, int\n"
		"errno_) Xapian::DatabaseError::DatabaseError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseError", _wrap_delete_DatabaseError, METH_O, NULL},
	 { "DatabaseError_swigregister", DatabaseError_swigregister, METH_O, NULL},
	 { "DatabaseError_swiginit", DatabaseError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseCorruptError", _wrap_new_DatabaseCorruptError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseCorruptError::DatabaseCorruptError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseCorruptError::DatabaseCorruptError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseCorruptError", _wrap_delete_DatabaseCorruptError, METH_O, NULL},
	 { "DatabaseCorruptError_swigregister", DatabaseCorruptError_swigregister, METH_O, NULL},
	 { "DatabaseCorruptError_swiginit", DatabaseCorruptError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseCreateError", _wrap_new_DatabaseCreateError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseCreateError::DatabaseCreateError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseCreateError::DatabaseCreateError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseCreateError", _wrap_delete_DatabaseCreateError, METH_O, NULL},
	 { "DatabaseCreateError_swigregister", DatabaseCreateError_swigregister, METH_O, NULL},
	 { "DatabaseCreateError_swiginit", DatabaseCreateError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseLockError", _wrap_new_DatabaseLockError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseLockError::DatabaseLockError(std::string_view msg_,\n"
		"int errno_) Xapian::DatabaseLockError::DatabaseLockError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseLockError", _wrap_delete_DatabaseLockError, METH_O, NULL},
	 { "DatabaseLockError_swigregister", DatabaseLockError_swigregister, METH_O, NULL},
	 { "DatabaseLockError_swiginit", DatabaseLockError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseModifiedError", _wrap_new_DatabaseModifiedError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseModifiedError::DatabaseModifiedError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseModifiedError::DatabaseModifiedError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseModifiedError", _wrap_delete_DatabaseModifiedError, METH_O, NULL},
	 { "DatabaseModifiedError_swigregister", DatabaseModifiedError_swigregister, METH_O, NULL},
	 { "DatabaseModifiedError_swiginit", DatabaseModifiedError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseOpeningError", _wrap_new_DatabaseOpeningError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseOpeningError::DatabaseOpeningError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseOpeningError::DatabaseOpeningError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseOpeningError", _wrap_delete_DatabaseOpeningError, METH_O, NULL},
	 { "DatabaseOpeningError_swigregister", DatabaseOpeningError_swigregister, METH_O, NULL},
	 { "DatabaseOpeningError_swiginit", DatabaseOpeningError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseVersionError", _wrap_new_DatabaseVersionError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseVersionError::DatabaseVersionError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseVersionError::DatabaseVersionError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseVersionError", _wrap_delete_DatabaseVersionError, METH_O, NULL},
	 { "DatabaseVersionError_swigregister", DatabaseVersionError_swigregister, METH_O, NULL},
	 { "DatabaseVersionError_swiginit", DatabaseVersionError_swiginit, METH_VARARGS, NULL},
	 { "new_DocNotFoundError", _wrap_new_DocNotFoundError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DocNotFoundError::DocNotFoundError(std::string_view msg_, int\n"
		"errno_) Xapian::DocNotFoundError::DocNotFoundError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DocNotFoundError", _wrap_delete_DocNotFoundError, METH_O, NULL},
	 { "DocNotFoundError_swigregister", DocNotFoundError_swigregister, METH_O, NULL},
	 { "DocNotFoundError_swiginit", DocNotFoundError_swiginit, METH_VARARGS, NULL},
	 { "new_FeatureUnavailableError", _wrap_new_FeatureUnavailableError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::FeatureUnavailableError::FeatureUnavailableError(std::string_view\n"
		"msg_, int errno_)\n"
		"Xapian::FeatureUnavailableError::FeatureUnavailableError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_FeatureUnavailableError", _wrap_delete_FeatureUnavailableError, METH_O, NULL},
	 { "FeatureUnavailableError_swigregister", FeatureUnavailableError_swigregister, METH_O, NULL},
	 { "FeatureUnavailableError_swiginit", FeatureUnavailableError_swiginit, METH_VARARGS, NULL},
	 { "new_InternalError", _wrap_new_InternalError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::InternalError::InternalError(std::string_view msg_, int\n"
		"errno_) Xapian::InternalError::InternalError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_InternalError", _wrap_delete_InternalError, METH_O, NULL},
	 { "InternalError_swigregister", InternalError_swigregister, METH_O, NULL},
	 { "InternalError_swiginit", InternalError_swiginit, METH_VARARGS, NULL},
	 { "new_NetworkError", _wrap_new_NetworkError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::NetworkError::NetworkError(std::string_view msg_, int errno_)\n"
		"Xapian::NetworkError::NetworkError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_NetworkError", _wrap_delete_NetworkError, METH_O, NULL},
	 { "NetworkError_swigregister", NetworkError_swigregister, METH_O, NULL},
	 { "NetworkError_swiginit", NetworkError_swiginit, METH_VARARGS, NULL},
	 { "new_NetworkTimeoutError", _wrap_new_NetworkTimeoutError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::NetworkTimeoutError::NetworkTimeoutError(std::string_view\n"
		"msg_, int errno_) Xapian::NetworkTimeoutError::NetworkTimeoutError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_NetworkTimeoutError", _wrap_delete_NetworkTimeoutError, METH_O, NULL},
	 { "NetworkTimeoutError_swigregister", NetworkTimeoutError_swigregister, METH_O, NULL},
	 { "NetworkTimeoutError_swiginit", NetworkTimeoutError_swiginit, METH_VARARGS, NULL},
	 { "new_QueryParserError", _wrap_new_QueryParserError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::QueryParserError::QueryParserError(std::string_view msg_, int\n"
		"errno_) Xapian::QueryParserError::QueryParserError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_QueryParserError", _wrap_delete_QueryParserError, METH_O, NULL},
	 { "QueryParserError_swigregister", QueryParserError_swigregister, METH_O, NULL},
	 { "QueryParserError_swiginit", QueryParserError_swiginit, METH_VARARGS, NULL},
	 { "new_SerialisationError", _wrap_new_SerialisationError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::SerialisationError::SerialisationError(std::string_view msg_,\n"
		"int errno_) Xapian::SerialisationError::SerialisationError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_SerialisationError", _wrap_delete_SerialisationError, METH_O, NULL},
	 { "SerialisationError_swigregister", SerialisationError_swigregister, METH_O, NULL},
	 { "SerialisationError_swiginit", SerialisationError_swiginit, METH_VARARGS, NULL},
	 { "new_RangeError", _wrap_new_RangeError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::RangeError::RangeError(std::string_view msg_, int errno_)\n"
		"Xapian::RangeError::RangeError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_RangeError", _wrap_delete_RangeError, METH_O, NULL},
	 { "RangeError_swigregister", RangeError_swigregister, METH_O, NULL},
	 { "RangeError_swiginit", RangeError_swiginit, METH_VARARGS, NULL},
	 { "new_WildcardError", _wrap_new_WildcardError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::WildcardError::WildcardError(std::string_view msg_, int\n"
		"errno_) Xapian::WildcardError::WildcardError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_WildcardError", _wrap_delete_WildcardError, METH_O, NULL},
	 { "WildcardError_swigregister", WildcardError_swigregister, METH_O, NULL},
	 { "WildcardError_swiginit", WildcardError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseNotFoundError", _wrap_new_DatabaseNotFoundError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseNotFoundError::DatabaseNotFoundError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseNotFoundError::DatabaseNotFoundError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseNotFoundError", _wrap_delete_DatabaseNotFoundError, METH_O, NULL},
	 { "DatabaseNotFoundError_swigregister", DatabaseNotFoundError_swigregister, METH_O, NULL},
	 { "DatabaseNotFoundError_swiginit", DatabaseNotFoundError_swiginit, METH_VARARGS, NULL},
	 { "new_DatabaseClosedError", _wrap_new_DatabaseClosedError, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct from message and errno value.\n"
		"\n"
		"Xapian::DatabaseClosedError::DatabaseClosedError(std::string_view\n"
		"msg_, int errno_) Xapian::DatabaseClosedError::DatabaseClosedError\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"msg_:  Message giving details of the error, intended for human\n"
		"consumption.\n"
		"\n"
		"errno_:  Optional errno value associated with this error. \n"
		""},
	 { "delete_DatabaseClosedError", _wrap_delete_DatabaseClosedError, METH_O, NULL},
	 { "DatabaseClosedError_swigregister", DatabaseClosedError_swigregister, METH_O, NULL},
	 { "DatabaseClosedError_swiginit", DatabaseClosedError_swiginit, METH_VARARGS, NULL},
	 { "version_string", _wrap_version_string, METH_NOARGS, NULL},
	 { "major_version", _wrap_major_version, METH_NOARGS, NULL},
	 { "minor_version", _wrap_minor_version, METH_NOARGS, NULL},
	 { "revision", _wrap_revision, METH_NOARGS, NULL},
	 { "new__PositionIterator", _wrap_new__PositionIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::PositionIterator::PositionIterator() noexcept\n"
		"Xapian::PositionIterator::PositionIterator Creates an uninitialised\n"
		"iterator, which can't be used before being assigned to, but is\n"
		"sometimes syntactically convenient. \n"
		""},
	 { "delete__PositionIterator", _wrap_delete__PositionIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::PositionIterator::~PositionIterator()\n"
		"Xapian::PositionIterator::~PositionIterator\n"
		""},
	 { "_PositionIterator_skip_to", _wrap__PositionIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to term position termpos.\n"
		"\n"
		"void Xapian::PositionIterator::skip_to(Xapian::termpos termpos)\n"
		"Xapian::PositionIterator::skip_to\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"termpos:  The position to advance to. If this position isn't in the\n"
		"stream being iterated, then the iterator is moved to the next term\n"
		"position after it which is. \n"
		""},
	 { "_PositionIterator___str__", _wrap__PositionIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::PositionIterator::get_description() const\n"
		"Xapian::PositionIterator::get_description\n"
		""},
	 { "_PositionIterator___eq__", _wrap__PositionIterator___eq__, METH_VARARGS, NULL},
	 { "_PositionIterator___ne__", _wrap__PositionIterator___ne__, METH_VARARGS, NULL},
	 { "_PositionIterator_equals", _wrap__PositionIterator_equals, METH_VARARGS, NULL},
	 { "_PositionIterator_get_termpos", _wrap__PositionIterator_get_termpos, METH_O, NULL},
	 { "_PositionIterator___next__", _wrap__PositionIterator___next__, METH_O, NULL},
	 { "_PositionIterator_swigregister", _PositionIterator_swigregister, METH_O, NULL},
	 { "_PositionIterator_swiginit", _PositionIterator_swiginit, METH_VARARGS, NULL},
	 { "new__PostingIterator", _wrap_new__PostingIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::PostingIterator::PostingIterator() noexcept\n"
		"Xapian::PostingIterator::PostingIterator Creates an uninitialised\n"
		"iterator, which can't be used before being assigned to, but is\n"
		"sometimes syntactically convenient. \n"
		""},
	 { "delete__PostingIterator", _wrap_delete__PostingIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::PostingIterator::~PostingIterator()\n"
		"Xapian::PostingIterator::~PostingIterator\n"
		""},
	 { "_PostingIterator_get_wdf", _wrap__PostingIterator_get_wdf, METH_O, "\n"
		"\n"
		"\n"
		"Return the wdf for the document at the current position.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_wdf() const\n"
		"Xapian::PostingIterator::get_wdf\n"
		""},
	 { "_PostingIterator_get_doclength", _wrap__PostingIterator_get_doclength, METH_O, "\n"
		"\n"
		"\n"
		"Return the length of the document at the current position.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_doclength() const\n"
		"Xapian::PostingIterator::get_doclength\n"
		""},
	 { "_PostingIterator_get_unique_terms", _wrap__PostingIterator_get_unique_terms, METH_O, "\n"
		"\n"
		"\n"
		"Return the number of unique terms in the current document.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_unique_terms() const\n"
		"Xapian::PostingIterator::get_unique_terms\n"
		""},
	 { "_PostingIterator_get_wdfdocmax", _wrap__PostingIterator_get_wdfdocmax, METH_O, "\n"
		"\n"
		"\n"
		"Return the max_wdf in the current document.\n"
		"\n"
		"Xapian::termcount Xapian::PostingIterator::get_wdfdocmax() const\n"
		"Xapian::PostingIterator::get_wdfdocmax\n"
		""},
	 { "_PostingIterator__positionlist_begin", _wrap__PostingIterator__positionlist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Return a PositionIterator for the current document.\n"
		"\n"
		"PositionIterator Xapian::PostingIterator::positionlist_begin() const\n"
		"Xapian::PostingIterator::positionlist_begin\n"
		""},
	 { "_PostingIterator__positionlist_end", _wrap__PostingIterator__positionlist_end, METH_O, "\n"
		"\n"
		"\n"
		"Return an end PositionIterator for the current document.\n"
		"\n"
		"PositionIterator Xapian::PostingIterator::positionlist_end() const\n"
		"noexcept Xapian::PostingIterator::positionlist_end\n"
		""},
	 { "_PostingIterator_skip_to", _wrap__PostingIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to document did.\n"
		"\n"
		"void Xapian::PostingIterator::skip_to(Xapian::docid did)\n"
		"Xapian::PostingIterator::skip_to\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to advance to. If this document id isn't in the\n"
		"stream being iterated, then the iterator is moved to the next document\n"
		"id after it which is. \n"
		""},
	 { "_PostingIterator___str__", _wrap__PostingIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::PostingIterator::get_description() const\n"
		"Xapian::PostingIterator::get_description\n"
		""},
	 { "_PostingIterator___eq__", _wrap__PostingIterator___eq__, METH_VARARGS, NULL},
	 { "_PostingIterator___ne__", _wrap__PostingIterator___ne__, METH_VARARGS, NULL},
	 { "_PostingIterator_equals", _wrap__PostingIterator_equals, METH_VARARGS, NULL},
	 { "_PostingIterator_get_docid", _wrap__PostingIterator_get_docid, METH_O, NULL},
	 { "_PostingIterator___next__", _wrap__PostingIterator___next__, METH_O, NULL},
	 { "_PostingIterator_swigregister", _PostingIterator_swigregister, METH_O, NULL},
	 { "_PostingIterator_swiginit", _PostingIterator_swiginit, METH_VARARGS, NULL},
	 { "new__TermIterator", _wrap_new__TermIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::TermIterator::TermIterator() noexcept\n"
		"Xapian::TermIterator::TermIterator Creates an uninitialised iterator,\n"
		"which can't be used before being assigned to, but is sometimes\n"
		"syntactically convenient. \n"
		""},
	 { "delete__TermIterator", _wrap_delete__TermIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::TermIterator::~TermIterator()\n"
		"Xapian::TermIterator::~TermIterator\n"
		""},
	 { "_TermIterator_get_wdf", _wrap__TermIterator_get_wdf, METH_O, "\n"
		"\n"
		"\n"
		"Return the wdf for the term at the current position.\n"
		"\n"
		"Xapian::termcount Xapian::TermIterator::get_wdf() const\n"
		"Xapian::TermIterator::get_wdf\n"
		""},
	 { "_TermIterator_get_termfreq", _wrap__TermIterator_get_termfreq, METH_O, "\n"
		"\n"
		"\n"
		"Return the term frequency for the term at the current position.\n"
		"\n"
		"Xapian::doccount Xapian::TermIterator::get_termfreq() const\n"
		"Xapian::TermIterator::get_termfreq Note that for a TermIterator\n"
		"returned by calling termlist_begin() on a Document object obtained\n"
		"from a sharded database, this method will return the term frequency\n"
		"from the shard that the document is in rather than for the combined\n"
		"database. \n"
		""},
	 { "_TermIterator_positionlist_count", _wrap__TermIterator_positionlist_count, METH_O, "\n"
		"\n"
		"\n"
		"Return the length of the position list for the current position.\n"
		"\n"
		"Xapian::termcount Xapian::TermIterator::positionlist_count() const\n"
		"Xapian::TermIterator::positionlist_count\n"
		""},
	 { "_TermIterator__positionlist_begin", _wrap__TermIterator__positionlist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Return a PositionIterator for the current term.\n"
		"\n"
		"PositionIterator Xapian::TermIterator::positionlist_begin() const\n"
		"Xapian::TermIterator::positionlist_begin\n"
		""},
	 { "_TermIterator__positionlist_end", _wrap__TermIterator__positionlist_end, METH_O, "\n"
		"\n"
		"\n"
		"Return an end PositionIterator for the current term.\n"
		"\n"
		"PositionIterator Xapian::TermIterator::positionlist_end() const\n"
		"noexcept Xapian::TermIterator::positionlist_end\n"
		""},
	 { "_TermIterator_skip_to", _wrap__TermIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to term term.\n"
		"\n"
		"void Xapian::TermIterator::skip_to(std::string_view term)\n"
		"Xapian::TermIterator::skip_to If the iteration is over an unsorted\n"
		"list of terms, then this method will throw\n"
		"Xapian::InvalidOperationError.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to advance to. If this term isn't in the stream being\n"
		"iterated, then the iterator is moved to the next term after it which\n"
		"is. \n"
		""},
	 { "_TermIterator___str__", _wrap__TermIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::TermIterator::get_description() const\n"
		"Xapian::TermIterator::get_description\n"
		""},
	 { "_TermIterator___eq__", _wrap__TermIterator___eq__, METH_VARARGS, NULL},
	 { "_TermIterator___ne__", _wrap__TermIterator___ne__, METH_VARARGS, NULL},
	 { "_TermIterator_equals", _wrap__TermIterator_equals, METH_VARARGS, NULL},
	 { "_TermIterator_get_term", _wrap__TermIterator_get_term, METH_O, NULL},
	 { "_TermIterator___next__", _wrap__TermIterator___next__, METH_O, NULL},
	 { "_TermIterator_swigregister", _TermIterator_swigregister, METH_O, NULL},
	 { "_TermIterator_swiginit", _TermIterator_swiginit, METH_VARARGS, NULL},
	 { "new__ValueIterator", _wrap_new__ValueIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::ValueIterator::ValueIterator() noexcept\n"
		"Xapian::ValueIterator::ValueIterator Creates an uninitialised\n"
		"iterator, which can't be used before being assigned to, but is\n"
		"sometimes syntactically convenient. \n"
		""},
	 { "delete__ValueIterator", _wrap_delete__ValueIterator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::ValueIterator::~ValueIterator()\n"
		"Xapian::ValueIterator::~ValueIterator\n"
		""},
	 { "_ValueIterator_get_docid", _wrap__ValueIterator_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Return the docid at the current position.\n"
		"\n"
		"Xapian::docid Xapian::ValueIterator::get_docid() const\n"
		"Xapian::ValueIterator::get_docid If we're iterating over values of a\n"
		"document, this method will throw Xapian::InvalidOperationError. \n"
		""},
	 { "_ValueIterator_get_valueno", _wrap__ValueIterator_get_valueno, METH_O, "\n"
		"\n"
		"\n"
		"Return the value slot number for the current position.\n"
		"\n"
		"Xapian::valueno Xapian::ValueIterator::get_valueno() const\n"
		"Xapian::ValueIterator::get_valueno If the iterator is over all values\n"
		"in a slot, this returns that slot's number. If the iterator is over\n"
		"the values in a particular document, it returns the number of each\n"
		"slot in turn. \n"
		""},
	 { "_ValueIterator_skip_to", _wrap__ValueIterator_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the iterator to document id or value slot docid_or_slot.\n"
		"\n"
		"void Xapian::ValueIterator::skip_to(Xapian::docid docid_or_slot)\n"
		"Xapian::ValueIterator::skip_to If this iterator is over values in a\n"
		"document, then this method advances the iterator to value slot\n"
		"docid_or_slot, or the first slot after it if there is no value in slot\n"
		"slot.\n"
		"\n"
		"If this iterator is over values in a particular slot, then this method\n"
		"advances the iterator to document id docid_or_slot, or the first\n"
		"document id after it if there is no value in the slot we're iterating\n"
		"over for document docid_or_slot.\n"
		"\n"
		"Note: The \"two-faced\" nature of this method is due to how C++\n"
		"overloading works. Xapian::docid and Xapian::valueno are both typedefs\n"
		"for the same unsigned integer type, so overloading can't distinguish\n"
		"them.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"docid_or_slot:  The docid/slot to advance to. \n"
		""},
	 { "_ValueIterator_check", _wrap__ValueIterator_check, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if the specified docid occurs.\n"
		"\n"
		"bool Xapian::ValueIterator::check(Xapian::docid docid)\n"
		"Xapian::ValueIterator::check The caller is required to ensure that the\n"
		"specified document id did actually exists in the database.\n"
		"\n"
		"This method acts like skip_to() if that can be done at little extra\n"
		"cost, in which case it then returns true. This is how glass databases\n"
		"behave because they store values in streams which allow for an\n"
		"efficient implementation of skip_to().\n"
		"\n"
		"Otherwise it simply checks if a particular docid is present. If it is,\n"
		"it returns true. If it isn't, it returns false, and leaves the\n"
		"position unspecified (and hence the result of calling methods which\n"
		"depend on the current position, such as get_docid(), are also\n"
		"unspecified). In this state, next() will advance to the first matching\n"
		"position after document did, and skip_to() will act as it would if the\n"
		"position was the first matching position after document did.\n"
		"\n"
		"Currently the inmemory and remote backends behave in the latter way\n"
		"because they don't support streamed values and so skip_to() must check\n"
		"each document it skips over which is significantly slower.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"docid:  The document id to check. \n"
		""},
	 { "_ValueIterator___str__", _wrap__ValueIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ValueIterator::get_description() const\n"
		"Xapian::ValueIterator::get_description\n"
		""},
	 { "_ValueIterator___eq__", _wrap__ValueIterator___eq__, METH_VARARGS, NULL},
	 { "_ValueIterator___ne__", _wrap__ValueIterator___ne__, METH_VARARGS, NULL},
	 { "_ValueIterator_equals", _wrap__ValueIterator_equals, METH_VARARGS, NULL},
	 { "_ValueIterator_get_value", _wrap__ValueIterator_get_value, METH_O, NULL},
	 { "_ValueIterator___next__", _wrap__ValueIterator___next__, METH_O, NULL},
	 { "_ValueIterator_swigregister", _ValueIterator_swigregister, METH_O, NULL},
	 { "_ValueIterator_swiginit", _ValueIterator_swiginit, METH_VARARGS, NULL},
	 { "new_Document", _wrap_new_Document, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::Document::Document() Xapian::Document::Document Creates an\n"
		"empty Document. \n"
		""},
	 { "delete_Document", _wrap_delete_Document, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Document::~Document() Xapian::Document::~Document\n"
		""},
	 { "Document_get_docid", _wrap_Document_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Get the document ID this document came from.\n"
		"\n"
		"Xapian::docid Xapian::Document::get_docid() const\n"
		"Xapian::Document::get_docid If this document didn't come from a\n"
		"database, this will be 0 (in Xapian 1.0.22/1.2.4 or later; prior to\n"
		"this the returned value was uninitialised in this case).\n"
		"\n"
		"Note that if the document came from a sharded database, this is the\n"
		"docid in the shard it came from, not the docid in the combined\n"
		"database. \n"
		""},
	 { "Document_get_data", _wrap_Document_get_data, METH_O, "\n"
		"\n"
		"\n"
		"Get the document data.\n"
		"\n"
		"std::string Xapian::Document::get_data() const\n"
		"Xapian::Document::get_data\n"
		""},
	 { "Document_set_data", _wrap_Document_set_data, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the document data.\n"
		"\n"
		"void Xapian::Document::set_data(std::string_view data)\n"
		"Xapian::Document::set_data This is an opaque blob as far as Xapian is\n"
		"concerned - it's up to you to impose whatever structure you want on\n"
		"it. If you want to store structured data, consider using something\n"
		"like protocol buffers. \n"
		""},
	 { "Document_add_term", _wrap_Document_add_term, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a term to this document.\n"
		"\n"
		"void Xapian::Document::add_term(std::string_view term,\n"
		"Xapian::termcount wdf_inc=1) Xapian::Document::add_term\n"
		""},
	 { "Document_add_boolean_term", _wrap_Document_add_boolean_term, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a boolean filter term to the document.\n"
		"\n"
		"void Xapian::Document::add_boolean_term(std::string_view term)\n"
		"Xapian::Document::add_boolean_term This method adds term to the\n"
		"document with wdf of 0 - this is generally what you want for a term\n"
		"used for boolean filtering as the wdf of such terms is ignored, and it\n"
		"doesn't make sense for them to contribute to the document's length.\n"
		"\n"
		"If the specified term already indexes this document, this method has\n"
		"no effect.\n"
		"\n"
		"It is exactly the same as add_term(term, 0) and is provided as a way\n"
		"to make a common operation more explicit.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to add.\n"
		"\n"
		"This method was added in Xapian 1.0.18. \n"
		""},
	 { "Document_remove_term", _wrap_Document_remove_term, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a term from this document.\n"
		"\n"
		"void Xapian::Document::remove_term(std::string_view term)\n"
		"Xapian::Document::remove_term\n"
		""},
	 { "Document_add_posting", _wrap_Document_add_posting, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a posting for a term.\n"
		"\n"
		"void Xapian::Document::add_posting(std::string_view term,\n"
		"Xapian::termpos term_pos, Xapian::termcount wdf_inc=1)\n"
		"Xapian::Document::add_posting\n"
		""},
	 { "Document_remove_posting", _wrap_Document_remove_posting, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove posting for a term.\n"
		"\n"
		"void Xapian::Document::remove_posting(std::string_view term,\n"
		"Xapian::termpos term_pos, Xapian::termcount wdf_dec=1)\n"
		"Xapian::Document::remove_posting The instance of the specified term at\n"
		"position term_pos will be removed, and the wdf reduced by wdf_dec (the\n"
		"wdf will not ever go below zero though - the resultant wdf is clamped\n"
		"to zero if it would).\n"
		"\n"
		"If the term doesn't occur at position term_pos then\n"
		"Xapian::InvalidArgumentError is thrown. If you want to remove a single\n"
		"position which may not be present without triggering an exception you\n"
		"can call remove_postings(term, pos, pos) instead.\n"
		"\n"
		"Since 2.0.0, if the final position is removed and the wdf becomes zero\n"
		"then the term will be removed from the document. \n"
		""},
	 { "Document_remove_postings", _wrap_Document_remove_postings, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a range of postings for a term.\n"
		"\n"
		"Xapian::termpos Xapian::Document::remove_postings(std::string_view\n"
		"term, Xapian::termpos term_pos_first, Xapian::termpos term_pos_last,\n"
		"Xapian::termcount wdf_dec=1) Xapian::Document::remove_postings Any\n"
		"instances of the term at positions >= term_pos_first and <=\n"
		"term_pos_last will be removed, and the wdf reduced by wdf_dec for each\n"
		"instance removed (the wdf will not ever go below zero though - the\n"
		"resultant wdf is clamped to zero if it would).\n"
		"\n"
		"If the term doesn't occur in the range of positions specified\n"
		"(including if term_pos_first > term_pos_last) then this method does\n"
		"nothing (unlike  remove_posting() which throws an exception if the\n"
		"specified position is not present).\n"
		"\n"
		"Since 2.0.0, if all remaining positions are removed and the wdf\n"
		"becomes zero then the term will be removed from the document. Note\n"
		"that this only happens if some positions are removed though - calling\n"
		"this method on a term which has no positions and zero wdf won't remove\n"
		"that term.\n"
		"\n"
		"The number of postings removed.\n"
		"\n"
		"Added in Xapian 1.4.8. \n"
		""},
	 { "Document_clear_terms", _wrap_Document_clear_terms, METH_O, "\n"
		"\n"
		"\n"
		"Clear all terms from the document.\n"
		"\n"
		"void Xapian::Document::clear_terms() Xapian::Document::clear_terms\n"
		""},
	 { "Document_termlist_count", _wrap_Document_termlist_count, METH_O, "\n"
		"\n"
		"\n"
		"Return the number of distinct terms in this document.\n"
		"\n"
		"Xapian::termcount Xapian::Document::termlist_count() const\n"
		"Xapian::Document::termlist_count\n"
		""},
	 { "Document__termlist_begin", _wrap_Document__termlist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Start iterating the terms in this document.\n"
		"\n"
		"TermIterator Xapian::Document::termlist_begin() const\n"
		"Xapian::Document::termlist_begin The terms are returned in ascending\n"
		"string order (by byte value).\n"
		"\n"
		"Note that if the Document object came from a sharded database then the\n"
		"TermIterator returned by this method only knows about the shard the\n"
		"document came from so calling get_termfreq() on it will give you the\n"
		"term frequency in that shard rather than in the combined database. \n"
		""},
	 { "Document__termlist_end", _wrap_Document__termlist_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to  termlist_begin().\n"
		"\n"
		"TermIterator Xapian::Document::termlist_end() const noexcept\n"
		"Xapian::Document::termlist_end\n"
		""},
	 { "Document_get_value", _wrap_Document_get_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Read a value slot in this document.\n"
		"\n"
		"std::string Xapian::Document::get_value(Xapian::valueno slot) const\n"
		"Xapian::Document::get_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The slot to read the value from\n"
		"\n"
		"The value in slot slot, or an empty string if not set. \n"
		""},
	 { "Document_add_value", _wrap_Document_add_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a value to a slot in this document.\n"
		"\n"
		"void Xapian::Document::add_value(Xapian::valueno slot,\n"
		"std::string_view value) Xapian::Document::add_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The slot to set\n"
		"\n"
		"value:  The new value \n"
		""},
	 { "Document_remove_value", _wrap_Document_remove_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove any value from the specified slot.\n"
		"\n"
		"void Xapian::Document::remove_value(Xapian::valueno slot)\n"
		"Xapian::Document::remove_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The slot to remove any value from. \n"
		""},
	 { "Document_clear_values", _wrap_Document_clear_values, METH_O, "\n"
		"\n"
		"\n"
		"Clear all value slots in this document.\n"
		"\n"
		"void Xapian::Document::clear_values() Xapian::Document::clear_values\n"
		""},
	 { "Document_values_count", _wrap_Document_values_count, METH_O, "\n"
		"\n"
		"\n"
		"Count the value slots used in this document.\n"
		"\n"
		"Xapian::valueno Xapian::Document::values_count() const\n"
		"Xapian::Document::values_count\n"
		""},
	 { "Document__values_begin", _wrap_Document__values_begin, METH_O, "\n"
		"\n"
		"\n"
		"Start iterating the values in this document.\n"
		"\n"
		"ValueIterator Xapian::Document::values_begin() const\n"
		"Xapian::Document::values_begin The values are returned in ascending\n"
		"numerical slot order. \n"
		""},
	 { "Document__values_end", _wrap_Document__values_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to  values_begin().\n"
		"\n"
		"ValueIterator Xapian::Document::values_end() const noexcept\n"
		"Xapian::Document::values_end\n"
		""},
	 { "Document_serialise", _wrap_Document_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Serialise document into a string.\n"
		"\n"
		"std::string Xapian::Document::serialise() const\n"
		"Xapian::Document::serialise The document representation may change\n"
		"between Xapian releases: even between minor versions. However, it is\n"
		"guaranteed not to change if the remote database protocol has not\n"
		"changed between releases. \n"
		""},
	 { "Document_unserialise", _wrap_Document_unserialise, METH_O, NULL},
	 { "Document___str__", _wrap_Document___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Document::get_description() const\n"
		"Xapian::Document::get_description\n"
		""},
	 { "Document_swigregister", Document_swigregister, METH_O, NULL},
	 { "Document_swiginit", Document_swiginit, METH_VARARGS, NULL},
	 { "new_Registry", _wrap_new_Registry, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::Registry::Registry() Xapian::Registry::Registry The registry\n"
		"will contain all standard subclasses of user-subclassable classes. \n"
		""},
	 { "delete_Registry", _wrap_delete_Registry, METH_O, "Xapian::Registry::~Registry() Xapian::Registry::~Registry"},
	 { "Registry_register_weighting_scheme", _wrap_Registry_register_weighting_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a weighting scheme.\n"
		"\n"
		"void Xapian::Registry::register_weighting_scheme(const Xapian::Weight\n"
		"&wt) Xapian::Registry::register_weighting_scheme\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wt:  The weighting scheme to register. \n"
		""},
	 { "Registry_get_weighting_scheme", _wrap_Registry_get_weighting_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the weighting scheme given a name.\n"
		"\n"
		"const Xapian::Weight *\n"
		"Xapian::Registry::get_weighting_scheme(std::string_view name) const\n"
		"Xapian::Registry::get_weighting_scheme\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the weighting scheme to find.\n"
		"\n"
		"An object with the requested name, or NULL if the weighting scheme\n"
		"could not be found. The returned object is owned by the registry and\n"
		"so must not be deleted by the caller. \n"
		""},
	 { "Registry_register_posting_source", _wrap_Registry_register_posting_source, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined posting source class.\n"
		"\n"
		"void Xapian::Registry::register_posting_source(const\n"
		"Xapian::PostingSource &source)\n"
		"Xapian::Registry::register_posting_source\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"source:  The posting source to register. \n"
		""},
	 { "Registry_get_posting_source", _wrap_Registry_get_posting_source, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a posting source given a name.\n"
		"\n"
		"const Xapian::PostingSource *\n"
		"Xapian::Registry::get_posting_source(std::string_view name) const\n"
		"Xapian::Registry::get_posting_source\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the posting source to find.\n"
		"\n"
		"An object with the requested name, or NULL if the posting source could\n"
		"not be found. The returned object is owned by the registry and so must\n"
		"not be deleted by the caller. \n"
		""},
	 { "Registry_register_match_spy", _wrap_Registry_register_match_spy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined match spy class.\n"
		"\n"
		"void Xapian::Registry::register_match_spy(const Xapian::MatchSpy &spy)\n"
		"Xapian::Registry::register_match_spy\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"spy:  The match spy to register. \n"
		""},
	 { "Registry_get_match_spy", _wrap_Registry_get_match_spy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a match spy given a name.\n"
		"\n"
		"const Xapian::MatchSpy *\n"
		"Xapian::Registry::get_match_spy(std::string_view name) const\n"
		"Xapian::Registry::get_match_spy\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the match spy to find.\n"
		"\n"
		"An object with the requested name, or NULL if the match spy could not\n"
		"be found. The returned object is owned by the registry and so must not\n"
		"be deleted by the caller. \n"
		""},
	 { "Registry_register_lat_long_metric", _wrap_Registry_register_lat_long_metric, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined lat-long metric class.\n"
		"\n"
		"void Xapian::Registry::register_lat_long_metric(const\n"
		"Xapian::LatLongMetric &metric)\n"
		"Xapian::Registry::register_lat_long_metric\n"
		""},
	 { "Registry_get_lat_long_metric", _wrap_Registry_get_lat_long_metric, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a lat-long metric given a name.\n"
		"\n"
		"const Xapian::LatLongMetric *\n"
		"Xapian::Registry::get_lat_long_metric(std::string_view name) const\n"
		"Xapian::Registry::get_lat_long_metric The returned metric is owned by\n"
		"the registry object.\n"
		"\n"
		"Returns NULL if the metric could not be found. \n"
		""},
	 { "Registry_register_key_maker", _wrap_Registry_register_key_maker, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a user-defined KeyMaker subclass.\n"
		"\n"
		"void Xapian::Registry::register_key_maker(Xapian::KeyMaker *keymaker)\n"
		"Xapian::Registry::register_key_maker\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"keymaker:  The KeyMaker subclass to register. The clean up of this\n"
		"object is handled via Xapian's optional reference counting. The\n"
		"simplest way to do so is to allocate it with new and call release() on\n"
		"it before passing it to this method to tell Xapian to manage its\n"
		"lifetime. The alternative approach is for the caller to ensure the\n"
		"KeyMaker object remains valid for the lifetime of the Registry object.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Registry_get_key_maker", _wrap_Registry_get_key_maker, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a KeyMaker given a name.\n"
		"\n"
		"const Xapian::KeyMaker *\n"
		"Xapian::Registry::get_key_maker(std::string_view name) const\n"
		"Xapian::Registry::get_key_maker\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"name:  The name of the KeyMaker to find.\n"
		"\n"
		"An object with the requested name, or NULL if the KeyMaker could not\n"
		"be found. The returned object must not be deleted by the caller.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Registry_swigregister", Registry_swigregister, METH_O, NULL},
	 { "Registry_swiginit", Registry_swiginit, METH_VARARGS, NULL},
	 { "delete_Query", _wrap_delete_Query, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Query::~Query() Xapian::Query::~Query\n"
		""},
	 { "Query__get_terms_begin", _wrap_Query__get_terms_begin, METH_O, "\n"
		"\n"
		"\n"
		"Begin iterator for terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_terms_begin() const\n"
		"Xapian::Query::get_terms_begin The iterator returns terms in ascending\n"
		"query position order, and will return the same term in each unique\n"
		"position it occurs in. If you want the terms in sorted order and\n"
		"without duplicates, see get_unique_terms_begin(). \n"
		""},
	 { "Query__get_terms_end", _wrap_Query__get_terms_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator for terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_terms_end() const noexcept\n"
		"Xapian::Query::get_terms_end\n"
		""},
	 { "Query_get_unique_terms_begin", _wrap_Query_get_unique_terms_begin, METH_O, "\n"
		"\n"
		"\n"
		"Begin iterator for unique terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_unique_terms_begin() const\n"
		"Xapian::Query::get_unique_terms_begin Terms are sorted and terms with\n"
		"the same name removed from the list.\n"
		"\n"
		"If you want the terms in ascending query position order, see\n"
		"get_terms_begin(). \n"
		""},
	 { "Query_get_unique_terms_end", _wrap_Query_get_unique_terms_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator for unique terms in the query object.\n"
		"\n"
		"const TermIterator Xapian::Query::get_unique_terms_end() const\n"
		"noexcept Xapian::Query::get_unique_terms_end\n"
		""},
	 { "Query_get_length", _wrap_Query_get_length, METH_O, "\n"
		"\n"
		"\n"
		"Return the length of this query object.\n"
		"\n"
		"Xapian::termcount Xapian::Query::get_length() const noexcept\n"
		"Xapian::Query::get_length\n"
		""},
	 { "Query_empty", _wrap_Query_empty, METH_O, "\n"
		"\n"
		"\n"
		"Check if this query is Xapian::Query::MatchNothing.\n"
		"\n"
		"bool Xapian::Query::empty() const noexcept Xapian::Query::empty\n"
		""},
	 { "Query_serialise", _wrap_Query_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Serialise this object into a string.\n"
		"\n"
		"std::string Xapian::Query::serialise() const\n"
		"Xapian::Query::serialise\n"
		""},
	 { "Query_unserialise", _wrap_Query_unserialise, METH_VARARGS, NULL},
	 { "Query_get_type", _wrap_Query_get_type, METH_O, "\n"
		"\n"
		"\n"
		"Get the type of the top level of the query.\n"
		"\n"
		"op Xapian::Query::get_type() const noexcept Xapian::Query::get_type\n"
		""},
	 { "Query_get_num_subqueries", _wrap_Query_get_num_subqueries, METH_O, "\n"
		"\n"
		"\n"
		"Get the number of subqueries of the top level query.\n"
		"\n"
		"size_t Xapian::Query::get_num_subqueries() const noexcept\n"
		"Xapian::Query::get_num_subqueries\n"
		""},
	 { "Query_get_leaf_wqf", _wrap_Query_get_leaf_wqf, METH_O, "\n"
		"\n"
		"\n"
		"Get the wqf parameter of a leaf node.\n"
		"\n"
		"Xapian::termcount Xapian::Query::get_leaf_wqf() const\n"
		"Xapian::Query::get_leaf_wqf\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Query_get_leaf_pos", _wrap_Query_get_leaf_pos, METH_O, "\n"
		"\n"
		"\n"
		"Get the pos parameter of a leaf node.\n"
		"\n"
		"Xapian::termpos Xapian::Query::get_leaf_pos() const\n"
		"Xapian::Query::get_leaf_pos\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Query_get_subquery", _wrap_Query_get_subquery, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Read a top level subquery.\n"
		"\n"
		"const Query Xapian::Query::get_subquery(size_t n) const\n"
		"Xapian::Query::get_subquery\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"n:  Return the n-th subquery (starting from 0) - only valid when 0 <=\n"
		"n < get_num_subqueries(). \n"
		""},
	 { "Query___str__", _wrap_Query___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Query::get_description() const\n"
		"Xapian::Query::get_description\n"
		""},
	 { "new_Query", _wrap_new_Query, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct with just an operator.\n"
		"\n"
		"Xapian::Query::Query(Query::op op_) Xapian::Query::Query\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"op_:  The operator to use - currently only OP_INVALID is useful. \n"
		""},
	 { "Query_swigregister", Query_swigregister, METH_O, NULL},
	 { "Query_swiginit", Query_swiginit, METH_VARARGS, NULL},
	 { "new_StemImplementation", _wrap_new_StemImplementation, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::StemImplementation::StemImplementation()\n"
		"Xapian::StemImplementation::StemImplementation\n"
		""},
	 { "delete_StemImplementation", _wrap_delete_StemImplementation, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor.\n"
		"\n"
		"virtual Xapian::StemImplementation::~StemImplementation()\n"
		"Xapian::StemImplementation::~StemImplementation\n"
		""},
	 { "StemImplementation___call__", _wrap_StemImplementation___call__, METH_VARARGS, NULL},
	 { "StemImplementation_use_proper_noun_heuristic", _wrap_StemImplementation_use_proper_noun_heuristic, METH_O, "\n"
		"\n"
		"\n"
		"Should QueryParser suppress stemming for capitalised words?\n"
		"\n"
		"virtual bool Xapian::StemImplementation::use_proper_noun_heuristic()\n"
		"const Xapian::StemImplementation::use_proper_noun_heuristic See\n"
		"QueryParser::feature_flag value FLAG_NO_PROPER_NOUN_HEURISTIC for\n"
		"details.\n"
		"\n"
		"The default implementation of this method returns false.\n"
		"\n"
		"Xapian 2.0.0. \n"
		""},
	 { "StemImplementation___str__", _wrap_StemImplementation___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::StemImplementation::get_description()\n"
		"const =0 Xapian::StemImplementation::get_description\n"
		""},
	 { "disown_StemImplementation", _wrap_disown_StemImplementation, METH_O, NULL},
	 { "StemImplementation_swigregister", StemImplementation_swigregister, METH_O, NULL},
	 { "StemImplementation_swiginit", StemImplementation_swiginit, METH_VARARGS, NULL},
	 { "new_Stem", _wrap_new_Stem, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a Xapian::Stem object with a user-provided stemming\n"
		"algorithm.\n"
		"\n"
		"Xapian::Stem::Stem(StemImplementation *p) Xapian::Stem::Stem You can\n"
		"subclass Xapian::StemImplementation to implement your own stemming\n"
		"algorithm (or to wrap a third-party algorithm) and then wrap your\n"
		"implementation in a Xapian::Stem object to pass to the Xapian API.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"p:  The user-subclassed StemImplementation object. This is reference\n"
		"counted, and so will be automatically deleted by the Xapian::Stem\n"
		"wrapper when no longer required. \n"
		""},
	 { "delete_Stem", _wrap_delete_Stem, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Stem::~Stem() Xapian::Stem::~Stem\n"
		""},
	 { "Stem___call__", _wrap_Stem___call__, METH_VARARGS, NULL},
	 { "Stem_is_none", _wrap_Stem_is_none, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this is a no-op stemmer.\n"
		"\n"
		"bool Xapian::Stem::is_none() const Xapian::Stem::is_none\n"
		""},
	 { "Stem___str__", _wrap_Stem___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Stem::get_description() const\n"
		"Xapian::Stem::get_description\n"
		""},
	 { "Stem_get_available_languages", _wrap_Stem_get_available_languages, METH_NOARGS, NULL},
	 { "Stem_swigregister", Stem_swigregister, METH_O, NULL},
	 { "Stem_swiginit", Stem_swiginit, METH_VARARGS, NULL},
	 { "new_TermGenerator", _wrap_new_TermGenerator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::TermGenerator::TermGenerator()\n"
		"Xapian::TermGenerator::TermGenerator\n"
		""},
	 { "delete_TermGenerator", _wrap_delete_TermGenerator, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::TermGenerator::~TermGenerator()\n"
		"Xapian::TermGenerator::~TermGenerator\n"
		""},
	 { "TermGenerator_set_stemmer", _wrap_TermGenerator_set_stemmer, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the Xapian::Stem object to be used for generating stemmed terms.\n"
		"\n"
		"void Xapian::TermGenerator::set_stemmer(const Xapian::Stem &stemmer)\n"
		"Xapian::TermGenerator::set_stemmer\n"
		""},
	 { "TermGenerator_set_stopper", _wrap_TermGenerator_set_stopper, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the Xapian::Stopper object to be used for identifying stopwords.\n"
		"\n"
		"void Xapian::TermGenerator::set_stopper(const Xapian::Stopper\n"
		"*stop=NULL) Xapian::TermGenerator::set_stopper Stemmed forms of\n"
		"stopwords aren't indexed, but unstemmed forms still are so that\n"
		"searches for phrases including stop words still work.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stop:  The Stopper object to set (default NULL, which means no\n"
		"stopwords). \n"
		""},
	 { "TermGenerator_set_document", _wrap_TermGenerator_set_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the current document.\n"
		"\n"
		"void Xapian::TermGenerator::set_document(const Xapian::Document &doc)\n"
		"Xapian::TermGenerator::set_document\n"
		""},
	 { "TermGenerator_get_document", _wrap_TermGenerator_get_document, METH_O, "\n"
		"\n"
		"\n"
		"Get the current document.\n"
		"\n"
		"const Xapian::Document & Xapian::TermGenerator::get_document() const\n"
		"Xapian::TermGenerator::get_document\n"
		""},
	 { "TermGenerator_set_database", _wrap_TermGenerator_set_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the database to index spelling data to.\n"
		"\n"
		"void Xapian::TermGenerator::set_database(const\n"
		"Xapian::WritableDatabase &db) Xapian::TermGenerator::set_database\n"
		""},
	 { "TermGenerator_set_flags", _wrap_TermGenerator_set_flags, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set flags.\n"
		"\n"
		"flags Xapian::TermGenerator::set_flags(flags toggle, flags\n"
		"mask=flags(0)) Xapian::TermGenerator::set_flags The new value of flags\n"
		"is: (flags & mask) ^ toggle\n"
		"\n"
		"To just set the flags, pass the new flags in toggle and the default\n"
		"value for mask.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"toggle:  Flags to XOR.\n"
		"\n"
		"mask:  Flags to AND with first.\n"
		"\n"
		"The old flags setting. \n"
		""},
	 { "TermGenerator_set_stemming_strategy", _wrap_TermGenerator_set_stemming_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stemming strategy.\n"
		"\n"
		"void Xapian::TermGenerator::set_stemming_strategy(stem_strategy\n"
		"strategy) Xapian::TermGenerator::set_stemming_strategy This method\n"
		"controls how the stemming algorithm is applied.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STEM_NONE: Don't\n"
		"perform any stemming - only unstemmed terms are generated.\n"
		"\n"
		"STEM_SOME: Generate both stemmed (with a \"Z\" prefix) and unstemmed\n"
		"terms. No positional information is stored for unstemmed terms. This\n"
		"is the default strategy.\n"
		"\n"
		"STEM_SOME_FULL_POS: Like STEM_SOME but positional information is\n"
		"stored for both stemmed and unstemmed terms. Added in Xapian 1.4.8.\n"
		"\n"
		"STEM_ALL: Generate only stemmed terms (but without a \"Z\" prefix).\n"
		"\n"
		"STEM_ALL_Z: Generate only stemmed terms (with a \"Z\" prefix).\n"
		"\n"
		"Added in Xapian 1.3.1. \n"
		""},
	 { "TermGenerator_set_stopper_strategy", _wrap_TermGenerator_set_stopper_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stopper strategy.\n"
		"\n"
		"void Xapian::TermGenerator::set_stopper_strategy(stop_strategy\n"
		"strategy) Xapian::TermGenerator::set_stopper_strategy The method\n"
		"controls how the stopper is used.\n"
		"\n"
		"You need to also call  set_stopper() for this to have any effect.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STOP_NONE: Don't\n"
		"use the stopper.\n"
		"\n"
		"STOP_ALL: If a word is identified as a stop word, skip it completely.\n"
		"\n"
		"STOP_STEMMED: If a word is identified as a stop word, index its\n"
		"unstemmed form but skip the stem. Unstemmed forms are indexed with\n"
		"positional information by default, so this allows searches for phrases\n"
		"containing stopwords to be supported. (This is the default mode).\n"
		"\n"
		"Added in Xapian 1.4.1. \n"
		""},
	 { "TermGenerator_set_max_word_length", _wrap_TermGenerator_set_max_word_length, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the maximum length word to index.\n"
		"\n"
		"void Xapian::TermGenerator::set_max_word_length(unsigned\n"
		"max_word_length) Xapian::TermGenerator::set_max_word_length The limit\n"
		"is on the length of a word prior to stemming and prior to adding any\n"
		"term prefix.\n"
		"\n"
		"The backends mostly impose a limit on the length of terms (often of\n"
		"about 240 bytes), but it's generally useful to have a lower limit to\n"
		"help prevent the index being bloated by useless junk terms from trying\n"
		"to indexing things like binary data, uuencoded data, ASCII art, etc.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_word_length:  The maximum length word to index, in bytes in UTF-8\n"
		"representation. Default is 64.\n"
		"\n"
		"Added in Xapian 1.3.1. \n"
		""},
	 { "TermGenerator_index_text", _wrap_TermGenerator_index_text, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Index some text.\n"
		"\n"
		"void Xapian::TermGenerator::index_text(std::string_view text,\n"
		"Xapian::termcount wdf_inc=1, std::string_view prefix={})\n"
		"Xapian::TermGenerator::index_text\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"text:  The text to index.\n"
		"\n"
		"wdf_inc:  The wdf increment (default 1).\n"
		"\n"
		"prefix:  The term prefix to use (default is no prefix). \n"
		""},
	 { "TermGenerator_index_text_without_positions", _wrap_TermGenerator_index_text_without_positions, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Index some text without positional information.\n"
		"\n"
		"void\n"
		"Xapian::TermGenerator::index_text_without_positions(std::string_view\n"
		"text, Xapian::termcount wdf_inc=1, std::string_view prefix={})\n"
		"Xapian::TermGenerator::index_text_without_positions Just like\n"
		"index_text, but no positional information is generated. This means\n"
		"that the database will be significantly smaller, but that phrase\n"
		"searching and NEAR won't be supported.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"text:  The text to index.\n"
		"\n"
		"wdf_inc:  The wdf increment (default 1).\n"
		"\n"
		"prefix:  The term prefix to use (default is no prefix). \n"
		""},
	 { "TermGenerator_increase_termpos", _wrap_TermGenerator_increase_termpos, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Increase the term position used by index_text.\n"
		"\n"
		"void Xapian::TermGenerator::increase_termpos(Xapian::termpos\n"
		"delta=100) Xapian::TermGenerator::increase_termpos This can be used\n"
		"between indexing text from different fields or other places to prevent\n"
		"phrase searches from spanning between them (e.g. between the title and\n"
		"body text, or between two chapters in a book).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"delta:  Amount to increase the term position by (default: 100). \n"
		""},
	 { "TermGenerator_get_termpos", _wrap_TermGenerator_get_termpos, METH_O, "\n"
		"\n"
		"\n"
		"Get the current term position.\n"
		"\n"
		"Xapian::termpos Xapian::TermGenerator::get_termpos() const\n"
		"Xapian::TermGenerator::get_termpos\n"
		""},
	 { "TermGenerator_set_termpos", _wrap_TermGenerator_set_termpos, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the current term position.\n"
		"\n"
		"void Xapian::TermGenerator::set_termpos(Xapian::termpos termpos)\n"
		"Xapian::TermGenerator::set_termpos\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"termpos:  The new term position to set. \n"
		""},
	 { "TermGenerator_set_termpos_limit", _wrap_TermGenerator_set_termpos_limit, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the term position limit.\n"
		"\n"
		"void Xapian::TermGenerator::set_termpos_limit(Xapian::termpos\n"
		"termpos_limit) Xapian::TermGenerator::set_termpos_limit\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"termpos_limit:  Upper bound on term positions that can be added.\n"
		"\n"
		"By default the only limit is the maximum value of the Xapian::termpos\n"
		"type.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "TermGenerator___str__", _wrap_TermGenerator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::TermGenerator::get_description() const\n"
		"Xapian::TermGenerator::get_description\n"
		""},
	 { "TermGenerator_swigregister", TermGenerator_swigregister, METH_O, NULL},
	 { "TermGenerator_swiginit", TermGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_MSet", _wrap_new_MSet, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::MSet::MSet() Xapian::MSet::MSet Creates an empty MSet, mostly\n"
		"useful as a placeholder. \n"
		""},
	 { "delete_MSet", _wrap_delete_MSet, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::MSet::~MSet() Xapian::MSet::~MSet\n"
		""},
	 { "MSet_sort_by_relevance", _wrap_MSet_sort_by_relevance, METH_O, "\n"
		"\n"
		"\n"
		"Sorts the list of documents in MSet according to their weights.\n"
		"\n"
		"void Xapian::MSet::sort_by_relevance() Xapian::MSet::sort_by_relevance\n"
		"Use after calling MSet::replace_weights.\n"
		"\n"
		"This invalidates any MSetIterator objects active on this MSet.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "MSet_convert_to_percent", _wrap_MSet_convert_to_percent, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Convert the weight of the current iterator position to a percentage.\n"
		"\n"
		"int Xapian::MSet::convert_to_percent(const MSetIterator &it) const\n"
		"Xapian::MSet::convert_to_percent If the weighting scheme gives\n"
		"everything zero weight (like Xapian::BoolWeight does) then all results\n"
		"will score 100%.\n"
		"\n"
		"Otherwise the percentage is calculated as a linear scaling of the\n"
		"relevance weight, with the scale factor determined by the matching\n"
		"document with the highest weight. This result scores 100% if it\n"
		"matches all the weighted query terms, and proportionally less if it\n"
		"only matches some.\n"
		"\n"
		"The returned percentage is an integer. If the calculated percentage\n"
		"before rounding is non-zero but less than 1% it is rounded up to 1% so\n"
		"that a result scoring 0% means it has zero weight.\n"
		"\n"
		"Similarly, percentages over 99% but less than 100% are always rounded\n"
		"down, so a result scoring 100% means it matches all weighted query\n"
		"terms.\n"
		"\n"
		"Note that these generally aren't percentages of anything meaningful\n"
		"(unless you use a custom weighting formula where they are!) but like\n"
		"the weights they are based on, higher values should indicate more\n"
		"relevant results. \n"
		""},
	 { "MSet_get_termfreq", _wrap_MSet_get_termfreq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the termfreq of a term.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_termfreq(std::string_view term)\n"
		"const Xapian::MSet::get_termfreq\n"
		"\n"
		"The number of documents which term occurs in. This considers all\n"
		"documents in the database being searched, so gives the same answer as\n"
		"db.get_termfreq(term) (but is more efficient for query terms as it\n"
		"returns a value cached during the search.)  Since 2.0.0, this method\n"
		"returns 0 if called on an MSet which is not associated with a database\n"
		"(which is consistent with Database::get_termfreq() returning 0 when\n"
		"called on a Database with no sub-databases); in earlier versions,\n"
		"Xapian::InvalidOperationError was thrown in this case. \n"
		""},
	 { "MSet_get_termweight", _wrap_MSet_get_termweight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the term weight of a term.\n"
		"\n"
		"double Xapian::MSet::get_termweight(std::string_view term) const\n"
		"Xapian::MSet::get_termweight\n"
		"\n"
		"The maximum weight that term could have contributed to a document.\n"
		"Since 2.0.0, this method returns 0.0 if called on an MSet which is not\n"
		"associated with a database, or with a term which wasn't present in the\n"
		"query (since in both cases the term contributes no weight to any\n"
		"matching documents); in earlier versions,\n"
		"Xapian::InvalidOperationError was thrown for the first case, and\n"
		"Xapian::InvalidArgumentError for the second. \n"
		""},
	 { "MSet_get_firstitem", _wrap_MSet_get_firstitem, METH_O, "\n"
		"\n"
		"\n"
		"Rank of first item in this MSet.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_firstitem() const\n"
		"Xapian::MSet::get_firstitem This is the parameter first passed to\n"
		"Xapian::Enquire::get_mset(). \n"
		""},
	 { "MSet_get_matches_lower_bound", _wrap_MSet_get_matches_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Lower bound on the total number of matching documents.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_matches_lower_bound() const\n"
		"Xapian::MSet::get_matches_lower_bound\n"
		""},
	 { "MSet_get_matches_estimated", _wrap_MSet_get_matches_estimated, METH_O, "\n"
		"\n"
		"\n"
		"Estimate of the total number of matching documents.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_matches_estimated() const\n"
		"Xapian::MSet::get_matches_estimated\n"
		""},
	 { "MSet_get_matches_upper_bound", _wrap_MSet_get_matches_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Upper bound on the total number of matching documents.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_matches_upper_bound() const\n"
		"Xapian::MSet::get_matches_upper_bound\n"
		""},
	 { "MSet_get_uncollapsed_matches_lower_bound", _wrap_MSet_get_uncollapsed_matches_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Lower bound on the total number of matching documents before\n"
		"collapsing.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_uncollapsed_matches_lower_bound()\n"
		"const Xapian::MSet::get_uncollapsed_matches_lower_bound Conceptually\n"
		"the same as get_matches_lower_bound() for the same query without any\n"
		"collapse part (though the actual value may differ). \n"
		""},
	 { "MSet_get_uncollapsed_matches_estimated", _wrap_MSet_get_uncollapsed_matches_estimated, METH_O, "\n"
		"\n"
		"\n"
		"Estimate of the total number of matching documents before collapsing.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_uncollapsed_matches_estimated()\n"
		"const Xapian::MSet::get_uncollapsed_matches_estimated Conceptually the\n"
		"same as get_matches_estimated() for the same query without any\n"
		"collapse part (though the actual value may differ). \n"
		""},
	 { "MSet_get_uncollapsed_matches_upper_bound", _wrap_MSet_get_uncollapsed_matches_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Upper bound on the total number of matching documents before\n"
		"collapsing.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::get_uncollapsed_matches_upper_bound()\n"
		"const Xapian::MSet::get_uncollapsed_matches_upper_bound Conceptually\n"
		"the same as get_matches_upper_bound() for the same query without any\n"
		"collapse part (though the actual value may differ). \n"
		""},
	 { "MSet_get_max_attained", _wrap_MSet_get_max_attained, METH_O, "\n"
		"\n"
		"\n"
		"The maximum weight attained by any document.\n"
		"\n"
		"double Xapian::MSet::get_max_attained() const\n"
		"Xapian::MSet::get_max_attained\n"
		""},
	 { "MSet_get_max_possible", _wrap_MSet_get_max_possible, METH_O, "\n"
		"\n"
		"\n"
		"The maximum possible weight any document could achieve.\n"
		"\n"
		"double Xapian::MSet::get_max_possible() const\n"
		"Xapian::MSet::get_max_possible\n"
		""},
	 { "MSet_snippet", _wrap_MSet_snippet, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Generate a snippet.\n"
		"\n"
		"std::string Xapian::MSet::snippet(std::string_view text, size_t\n"
		"length=500, const Xapian::Stem &stemmer=Xapian::Stem(), unsigned\n"
		"flags=SNIPPET_BACKGROUND_MODEL|SNIPPET_EXHAUSTIVE, std::string_view\n"
		"hi_start=\"<b>\", std::string_view hi_end=\"</b>\", std::string_view\n"
		"omit=\"...\") const Xapian::MSet::snippet This method selects a\n"
		"continuous run of words from text, based mainly on where the query\n"
		"matches (currently terms, exact phrases and wildcards are taken into\n"
		"account). If flag SNIPPET_BACKGROUND_MODEL is used (which it is by\n"
		"default) then the selection algorithm also considers the non-query\n"
		"terms in the text with the aim of showing a context which provides\n"
		"more useful information.\n"
		"\n"
		"The size of the text selected can be controlled by the length\n"
		"parameter, which specifies a number of bytes of text to aim to select.\n"
		"However slightly more text may be selected. Also the size of any\n"
		"escaping, highlighting or omission markers is not considered.\n"
		"\n"
		"The returned text is escaped to make it suitable for use in HTML/XML,\n"
		"and matches with the query will be highlighted using hi_start and\n"
		"hi_end.\n"
		"\n"
		"If the snippet seems to start or end mid-sentence, then omit is\n"
		"prepended or append (respectively) to indicate this.\n"
		"\n"
		"The same stemming algorithm which was used to build the query should\n"
		"be specified in stemmer.\n"
		"\n"
		"And flags contains flags controlling behaviour.\n"
		"\n"
		"Beware that in upstream releases 1.4.5 and earlier the escaping was\n"
		"sometimes incomplete; 1.4.32 and 2.1.0 fixed another case of missing\n"
		"escaping when hi_start and hi_end were both specified as empty strings\n"
		"and text was already within the requested length.\n"
		"\n"
		"Added in 1.3.5. \n"
		""},
	 { "MSet_fetch", _wrap_MSet_fetch, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Prefetch hint the whole MSet.\n"
		"\n"
		"void Xapian::MSet::fetch() const Xapian::MSet::fetch For a remote\n"
		"database, this may start a pipelined fetch of the requested documents\n"
		"from the remote server.\n"
		"\n"
		"For a disk-based database, this may send prefetch hints to the\n"
		"operating system such that the disk blocks the requested documents are\n"
		"stored in are more likely to be in the cache when we come to actually\n"
		"read them. \n"
		""},
	 { "MSet_size", _wrap_MSet_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of items in this MSet object.\n"
		"\n"
		"Xapian::doccount Xapian::MSet::size() const Xapian::MSet::size\n"
		""},
	 { "MSet_empty", _wrap_MSet_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this MSet object is empty.\n"
		"\n"
		"bool Xapian::MSet::empty() const Xapian::MSet::empty\n"
		""},
	 { "MSet__begin", _wrap_MSet__begin, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the first item in this MSet.\n"
		"\n"
		"MSetIterator Xapian::MSet::begin() const Xapian::MSet::begin\n"
		""},
	 { "MSet__end", _wrap_MSet__end, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to just after the last item in this MSet.\n"
		"\n"
		"MSetIterator Xapian::MSet::end() const Xapian::MSet::end\n"
		""},
	 { "MSet_back", _wrap_MSet_back, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the last object in this MSet.\n"
		"\n"
		"MSetIterator Xapian::MSet::back() const Xapian::MSet::back\n"
		""},
	 { "MSet___str__", _wrap_MSet___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::MSet::get_description() const\n"
		"Xapian::MSet::get_description\n"
		""},
	 { "MSet_get_docid", _wrap_MSet_get_docid, METH_VARARGS, NULL},
	 { "MSet_get_document", _wrap_MSet_get_document, METH_VARARGS, NULL},
	 { "MSet__get_hit_internal", _wrap_MSet__get_hit_internal, METH_VARARGS, "\n"
		"Get an item from the MSet.\n"
		"\n"
		"The supplied index is relative to the start of the MSet, not the absolute rank\n"
		"of the item. \n"
		""},
	 { "MSet_get_document_percentage", _wrap_MSet_get_document_percentage, METH_VARARGS, NULL},
	 { "MSet_swigregister", MSet_swigregister, METH_O, NULL},
	 { "MSet_swiginit", MSet_swiginit, METH_VARARGS, NULL},
	 { "_MSetIterator_mset_set", _wrap__MSetIterator_mset_set, METH_VARARGS, NULL},
	 { "_MSetIterator_mset_get", _wrap__MSetIterator_mset_get, METH_O, NULL},
	 { "_MSetIterator_off_from_end_set", _wrap__MSetIterator_off_from_end_set, METH_VARARGS, NULL},
	 { "_MSetIterator_off_from_end_get", _wrap__MSetIterator_off_from_end_get, METH_O, NULL},
	 { "new__MSetIterator", _wrap_new__MSetIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Create an unpositioned MSetIterator.\n"
		"\n"
		"Xapian::MSetIterator::MSetIterator()\n"
		"Xapian::MSetIterator::MSetIterator\n"
		""},
	 { "_MSetIterator_get_rank", _wrap__MSetIterator_get_rank, METH_O, "\n"
		"\n"
		"\n"
		"Return the MSet rank for the current position.\n"
		"\n"
		"Xapian::doccount Xapian::MSetIterator::get_rank() const\n"
		"Xapian::MSetIterator::get_rank The rank of mset[0] is\n"
		"mset.get_firstitem(). \n"
		""},
	 { "_MSetIterator_get_document", _wrap__MSetIterator_get_document, METH_O, "\n"
		"\n"
		"\n"
		"Get the Document object for the current position.\n"
		"\n"
		"Xapian::Document Xapian::MSetIterator::get_document() const\n"
		"Xapian::MSetIterator::get_document\n"
		""},
	 { "_MSetIterator_get_weight", _wrap__MSetIterator_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Get the weight for the current position.\n"
		"\n"
		"double Xapian::MSetIterator::get_weight() const\n"
		"Xapian::MSetIterator::get_weight\n"
		""},
	 { "_MSetIterator_get_collapse_key", _wrap__MSetIterator_get_collapse_key, METH_O, "\n"
		"\n"
		"\n"
		"Return the collapse key for the current position.\n"
		"\n"
		"std::string Xapian::MSetIterator::get_collapse_key() const\n"
		"Xapian::MSetIterator::get_collapse_key If collapsing isn't in use, an\n"
		"empty string will be returned. \n"
		""},
	 { "_MSetIterator_get_collapse_count", _wrap__MSetIterator_get_collapse_count, METH_O, "\n"
		"\n"
		"\n"
		"Return a count of the number of collapses done onto the current key.\n"
		"\n"
		"Xapian::doccount Xapian::MSetIterator::get_collapse_count() const\n"
		"Xapian::MSetIterator::get_collapse_count This starts at 0, and is\n"
		"incremented each time an item is eliminated because its key is the\n"
		"same as that of the current item (as returned by get_collapse_key()).\n"
		"\n"
		"Note that this is NOT necessarily one less than the total number of\n"
		"matching documents with this collapse key due to various optimisations\n"
		"implemented in the matcher - for example, it can skip documents\n"
		"completely if it can prove their weight wouldn't be enough to make the\n"
		"result set.\n"
		"\n"
		"You can say is that if get_collapse_count() > 0 then there are >=\n"
		"get_collapse_count() other documents with the current collapse key.\n"
		"But if get_collapse_count() == 0 then there may or may not be other\n"
		"such documents. \n"
		""},
	 { "_MSetIterator_get_sort_key", _wrap__MSetIterator_get_sort_key, METH_O, "\n"
		"\n"
		"\n"
		"Return the sort key for the current position.\n"
		"\n"
		"std::string Xapian::MSetIterator::get_sort_key() const\n"
		"Xapian::MSetIterator::get_sort_key If sorting didn't use a key then an\n"
		"empty string will be returned.\n"
		"\n"
		"Added in Xapian 1.4.6. \n"
		""},
	 { "_MSetIterator_get_percent", _wrap__MSetIterator_get_percent, METH_O, "\n"
		"\n"
		"\n"
		"Convert the weight of the current iterator position to a percentage.\n"
		"\n"
		"int Xapian::MSetIterator::get_percent() const\n"
		"Xapian::MSetIterator::get_percent If the weighting scheme gives\n"
		"everything zero weight (like Xapian::BoolWeight does) then all results\n"
		"will score 100%.\n"
		"\n"
		"Otherwise the percentage is calculated as a linear scaling of the\n"
		"relevance weight, with the scale factor determined by the matching\n"
		"document with the highest weight. This result scores 100% if it\n"
		"matches all the weighted query terms, and proportionally less if it\n"
		"only matches some.\n"
		"\n"
		"The returned percentage is an integer. If the calculated percentage\n"
		"before rounding is non-zero but less than 1% it is rounded up to 1% so\n"
		"that a result scoring 0% means it has zero weight.\n"
		"\n"
		"Similarly, percentages over 99% but less than 100% are always rounded\n"
		"down, so a result scoring 100% means it matches all weighted query\n"
		"terms.\n"
		"\n"
		"Note that these generally aren't percentages of anything meaningful\n"
		"(unless you use a custom weighting formula where they are!) but like\n"
		"the weights they are based on, higher values should indicate more\n"
		"relevant results. \n"
		""},
	 { "_MSetIterator___str__", _wrap__MSetIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::MSetIterator::get_description() const\n"
		"Xapian::MSetIterator::get_description\n"
		""},
	 { "_MSetIterator___eq__", _wrap__MSetIterator___eq__, METH_VARARGS, NULL},
	 { "_MSetIterator___ne__", _wrap__MSetIterator___ne__, METH_VARARGS, NULL},
	 { "_MSetIterator_equals", _wrap__MSetIterator_equals, METH_VARARGS, NULL},
	 { "_MSetIterator_get_docid", _wrap__MSetIterator_get_docid, METH_O, NULL},
	 { "_MSetIterator___next__", _wrap__MSetIterator___next__, METH_O, NULL},
	 { "_MSetIterator_prev", _wrap__MSetIterator_prev, METH_O, NULL},
	 { "delete__MSetIterator", _wrap_delete__MSetIterator, METH_O, NULL},
	 { "_MSetIterator_swigregister", _MSetIterator_swigregister, METH_O, NULL},
	 { "_MSetIterator_swiginit", _MSetIterator_swiginit, METH_VARARGS, NULL},
	 { "new_ESet", _wrap_new_ESet, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::ESet::ESet() Xapian::ESet::ESet Creates an empty ESet, mostly\n"
		"useful as a placeholder. \n"
		""},
	 { "delete_ESet", _wrap_delete_ESet, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::ESet::~ESet() Xapian::ESet::~ESet\n"
		""},
	 { "ESet_size", _wrap_ESet_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of items in this ESet object.\n"
		"\n"
		"Xapian::termcount Xapian::ESet::size() const Xapian::ESet::size\n"
		""},
	 { "ESet_empty", _wrap_ESet_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this ESet object is empty.\n"
		"\n"
		"bool Xapian::ESet::empty() const Xapian::ESet::empty\n"
		""},
	 { "ESet_get_ebound", _wrap_ESet_get_ebound, METH_O, "\n"
		"\n"
		"\n"
		"Return a bound on the full size of this ESet object.\n"
		"\n"
		"Xapian::termcount Xapian::ESet::get_ebound() const\n"
		"Xapian::ESet::get_ebound This is a bound on size() if get_eset() had\n"
		"been called with maxitems set high enough that all results were\n"
		"returned. \n"
		""},
	 { "ESet__begin", _wrap_ESet__begin, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the first item in this ESet.\n"
		"\n"
		"ESetIterator Xapian::ESet::begin() const Xapian::ESet::begin\n"
		""},
	 { "ESet__end", _wrap_ESet__end, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to just after the last item in this ESet.\n"
		"\n"
		"ESetIterator Xapian::ESet::end() const Xapian::ESet::end\n"
		""},
	 { "ESet_back", _wrap_ESet_back, METH_O, "\n"
		"\n"
		"\n"
		"Return iterator pointing to the last object in this ESet.\n"
		"\n"
		"ESetIterator Xapian::ESet::back() const Xapian::ESet::back\n"
		""},
	 { "ESet___str__", _wrap_ESet___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ESet::get_description() const\n"
		"Xapian::ESet::get_description\n"
		""},
	 { "ESet_swigregister", ESet_swigregister, METH_O, NULL},
	 { "ESet_swiginit", ESet_swiginit, METH_VARARGS, NULL},
	 { "_ESetIterator_eset_set", _wrap__ESetIterator_eset_set, METH_VARARGS, NULL},
	 { "_ESetIterator_eset_get", _wrap__ESetIterator_eset_get, METH_O, NULL},
	 { "_ESetIterator_off_from_end_set", _wrap__ESetIterator_off_from_end_set, METH_VARARGS, NULL},
	 { "_ESetIterator_off_from_end_get", _wrap__ESetIterator_off_from_end_get, METH_O, NULL},
	 { "new__ESetIterator", _wrap_new__ESetIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Create an unpositioned ESetIterator.\n"
		"\n"
		"Xapian::ESetIterator::ESetIterator()\n"
		"Xapian::ESetIterator::ESetIterator\n"
		""},
	 { "_ESetIterator_get_weight", _wrap__ESetIterator_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Get the weight for the current position.\n"
		"\n"
		"double Xapian::ESetIterator::get_weight() const\n"
		"Xapian::ESetIterator::get_weight\n"
		""},
	 { "_ESetIterator___str__", _wrap__ESetIterator___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ESetIterator::get_description() const\n"
		"Xapian::ESetIterator::get_description\n"
		""},
	 { "_ESetIterator___eq__", _wrap__ESetIterator___eq__, METH_VARARGS, NULL},
	 { "_ESetIterator___ne__", _wrap__ESetIterator___ne__, METH_VARARGS, NULL},
	 { "_ESetIterator_equals", _wrap__ESetIterator_equals, METH_VARARGS, NULL},
	 { "_ESetIterator_get_term", _wrap__ESetIterator_get_term, METH_O, NULL},
	 { "_ESetIterator___next__", _wrap__ESetIterator___next__, METH_O, NULL},
	 { "_ESetIterator_prev", _wrap__ESetIterator_prev, METH_O, NULL},
	 { "delete__ESetIterator", _wrap_delete__ESetIterator, METH_O, NULL},
	 { "_ESetIterator_swigregister", _ESetIterator_swigregister, METH_O, NULL},
	 { "_ESetIterator_swiginit", _ESetIterator_swiginit, METH_VARARGS, NULL},
	 { "__eq__", _wrap___eq__, METH_VARARGS, NULL},
	 { "__lt__", _wrap___lt__, METH_VARARGS, NULL},
	 { "__gt__", _wrap___gt__, METH_VARARGS, NULL},
	 { "__ge__", _wrap___ge__, METH_VARARGS, NULL},
	 { "__le__", _wrap___le__, METH_VARARGS, NULL},
	 { "__add__", _wrap___add__, METH_VARARGS, NULL},
	 { "new_RSet", _wrap_new_RSet, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::RSet::RSet() Xapian::RSet::RSet Creates an empty RSet. \n"
		""},
	 { "delete_RSet", _wrap_delete_RSet, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::RSet::~RSet() Xapian::RSet::~RSet\n"
		""},
	 { "RSet_size", _wrap_RSet_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of documents in this RSet object.\n"
		"\n"
		"Xapian::doccount Xapian::RSet::size() const Xapian::RSet::size\n"
		""},
	 { "RSet_empty", _wrap_RSet_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if this RSet object is empty.\n"
		"\n"
		"bool Xapian::RSet::empty() const Xapian::RSet::empty\n"
		""},
	 { "RSet_add_document", _wrap_RSet_add_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Mark a document as relevant.\n"
		"\n"
		"void Xapian::RSet::add_document(const Xapian::MSetIterator &it)\n"
		"Xapian::RSet::add_document If did is already marked as relevant,\n"
		"nothing happens. \n"
		""},
	 { "RSet_remove_document", _wrap_RSet_remove_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unmark a document as relevant.\n"
		"\n"
		"void Xapian::RSet::remove_document(const Xapian::MSetIterator &it)\n"
		"Xapian::RSet::remove_document If did is not marked as relevant,\n"
		"nothing happens. \n"
		""},
	 { "RSet_contains", _wrap_RSet_contains, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if a document is marked as relevant.\n"
		"\n"
		"bool Xapian::RSet::contains(const Xapian::MSetIterator &it) const\n"
		"Xapian::RSet::contains\n"
		""},
	 { "RSet___str__", _wrap_RSet___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::RSet::get_description() const\n"
		"Xapian::RSet::get_description\n"
		""},
	 { "RSet_swigregister", RSet_swigregister, METH_O, NULL},
	 { "RSet_swiginit", RSet_swiginit, METH_VARARGS, NULL},
	 { "new_MatchDecider", _wrap_new_MatchDecider, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor, needed by subclass constructors.\n"
		"\n"
		"Xapian::MatchDecider::MatchDecider() noexcept\n"
		"Xapian::MatchDecider::MatchDecider\n"
		""},
	 { "delete_MatchDecider", _wrap_delete_MatchDecider, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::MatchDecider::~MatchDecider()\n"
		"Xapian::MatchDecider::~MatchDecider\n"
		""},
	 { "MatchDecider___call__", _wrap_MatchDecider___call__, METH_VARARGS, NULL},
	 { "disown_MatchDecider", _wrap_disown_MatchDecider, METH_O, NULL},
	 { "MatchDecider_swigregister", MatchDecider_swigregister, METH_O, NULL},
	 { "MatchDecider_swiginit", MatchDecider_swiginit, METH_VARARGS, NULL},
	 { "new_Enquire", _wrap_new_Enquire, METH_O, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::Enquire::Enquire(const Database &db) Xapian::Enquire::Enquire\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database (or databases) to query.\n"
		"\n"
		"2.0.0 If db has no subdatabases, it's handled like any other empty\n"
		"database. In earlier versions, Xapian::InvalidArgumentError was thrown\n"
		"in this case. \n"
		""},
	 { "delete_Enquire", _wrap_delete_Enquire, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::Enquire::~Enquire() Xapian::Enquire::~Enquire\n"
		""},
	 { "Enquire_set_query", _wrap_Enquire_set_query, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the query.\n"
		"\n"
		"void Xapian::Enquire::set_query(const Query &query, termcount\n"
		"query_length=0) Xapian::Enquire::set_query If set_query() is not\n"
		"called before calling get_mset(), the default query used will be\n"
		"Xapian::MatchNothing.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"query:  The Xapian::Query object\n"
		"\n"
		"query_length:  The query length to use (default: query.get_length())\n"
		"\n"
		""},
	 { "Enquire_get_query", _wrap_Enquire_get_query, METH_O, "\n"
		"\n"
		"\n"
		"Get the currently set query.\n"
		"\n"
		"const Query & Xapian::Enquire::get_query() const\n"
		"Xapian::Enquire::get_query If set_query() is not called before calling\n"
		"get_query(), then the default query Xapian::MatchNothing will be\n"
		"returned. \n"
		""},
	 { "Enquire_set_weighting_scheme", _wrap_Enquire_set_weighting_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the weighting scheme to use.\n"
		"\n"
		"void Xapian::Enquire::set_weighting_scheme(const Weight &weight)\n"
		"Xapian::Enquire::set_weighting_scheme The Xapian::Weight object passed\n"
		"is cloned by calling weight.clone(), so doesn't need to remain valid\n"
		"after the call.\n"
		"\n"
		"If set_weighting_scheme() is not called before calling get_mset(), the\n"
		"default weighting scheme is Xapian::BM25Weight().\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"weight:   Xapian::Weight object \n"
		""},
	 { "Enquire_set_docid_order", _wrap_Enquire_set_docid_order, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set sort order for document IDs.\n"
		"\n"
		"void Xapian::Enquire::set_docid_order(docid_order order)\n"
		"Xapian::Enquire::set_docid_order This order only has an effect on\n"
		"documents which would otherwise have equal rank. When ordering by\n"
		"relevance without a sort key, this means documents with equal weight.\n"
		"For a boolean match with no sort key, this means all documents. And if\n"
		"a sort key is used, this means documents with the same sort key (and\n"
		"also equal weight if ordering on relevance before or after the sort\n"
		"key).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"order:  This can be:  Xapian::Enquire::ASCENDING docids sort in\n"
		"ascending order (default)\n"
		"\n"
		"Xapian::Enquire::DESCENDING docids sort in descending order\n"
		"\n"
		"Xapian::Enquire::DONT_CARE docids sort in whatever order is most\n"
		"efficient for the backend\n"
		"\n"
		"Note: If you add documents in strict date order, then a boolean search\n"
		"- i.e. set_weighting_scheme(Xapian::BoolWeight()) - with\n"
		"set_docid_order(Xapian::Enquire::DESCENDING) is an efficient way to\n"
		"perform \"sort by date, newest first\", and with\n"
		"set_docid_order(Xapian::Enquire::ASCENDING) a very efficient way to\n"
		"perform \"sort by date, oldest first\". \n"
		""},
	 { "Enquire_set_sort_by_relevance", _wrap_Enquire_set_sort_by_relevance, METH_O, "\n"
		"\n"
		"\n"
		"Set the sorting to be by relevance only.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_relevance()\n"
		"Xapian::Enquire::set_sort_by_relevance This is the default. \n"
		""},
	 { "Enquire_set_sort_by_value", _wrap_Enquire_set_sort_by_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by value only.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_value(valueno sort_key, bool\n"
		"reverse) Xapian::Enquire::set_sort_by_value Note that sorting by\n"
		"values uses a string comparison, so to use this to sort by a numeric\n"
		"value you'll need to store the numeric values in a manner which sorts\n"
		"appropriately. For example, you could use Xapian::sortable_serialise()\n"
		"(which works for floating point numbers as well as integers), or store\n"
		"numbers padded with leading zeros or spaces, or with the number of\n"
		"digits prepended.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sort_key:  value number to sort on.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_key", _wrap_Enquire_set_sort_by_key, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by key generated from values only.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_key(KeyMaker *sorter, bool reverse)\n"
		"XAPIAN_NONNULL() Xapian::Enquire::set_sort_by_key\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sorter:  The functor to use for generating keys.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_value_then_relevance", _wrap_Enquire_set_sort_by_value_then_relevance, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by value, then by relevance for documents with\n"
		"the same value.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_value_then_relevance(valueno\n"
		"sort_key, bool reverse)\n"
		"Xapian::Enquire::set_sort_by_value_then_relevance Note that sorting by\n"
		"values uses a string comparison, so to use this to sort by a numeric\n"
		"value you'll need to store the numeric values in a manner which sorts\n"
		"appropriately. For example, you could use Xapian::sortable_serialise()\n"
		"(which works for floating point numbers as well as integers), or store\n"
		"numbers padded with leading zeros or spaces, or with the number of\n"
		"digits prepended.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sort_key:  value number to sort on.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_key_then_relevance", _wrap_Enquire_set_sort_by_key_then_relevance, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by keys generated from values, then by relevance\n"
		"for documents with identical keys.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_key_then_relevance(KeyMaker *sorter,\n"
		"bool reverse) XAPIAN_NONNULL()\n"
		"Xapian::Enquire::set_sort_by_key_then_relevance\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sorter:  The functor to use for generating keys.\n"
		"\n"
		"reverse:  If true, reverses the sort order. \n"
		""},
	 { "Enquire_set_sort_by_relevance_then_value", _wrap_Enquire_set_sort_by_relevance_then_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by relevance then value.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_relevance_then_value(valueno\n"
		"sort_key, bool reverse)\n"
		"Xapian::Enquire::set_sort_by_relevance_then_value Note that sorting by\n"
		"values uses a string comparison, so to use this to sort by a numeric\n"
		"value you'll need to store the numeric values in a manner which sorts\n"
		"appropriately. For example, you could use Xapian::sortable_serialise()\n"
		"(which works for floating point numbers as well as integers), or store\n"
		"numbers padded with leading zeros or spaces, or with the number of\n"
		"digits prepended.\n"
		"\n"
		"Note that with the default BM25 weighting scheme parameters, non-\n"
		"identical documents will rarely have the same weight, so this setting\n"
		"will give very similar results to set_sort_by_relevance(). It becomes\n"
		"more useful with particular BM25 parameter settings (e.g.\n"
		"BM25Weight(1,0,1,0,0)) or custom weighting schemes.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sort_key:  value number to sort on.\n"
		"\n"
		"reverse:  If true, reverses the sort order of sort_key. Beware that in\n"
		"1.2.16 and earlier, the sense of this parameter was incorrectly\n"
		"inverted and inconsistent with the other set_sort_by_... methods. This\n"
		"was fixed in 1.2.17, so make that version a minimum requirement if\n"
		"this detail matters to your application. \n"
		""},
	 { "Enquire_set_sort_by_relevance_then_key", _wrap_Enquire_set_sort_by_relevance_then_key, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the sorting to be by relevance, then by keys generated from\n"
		"values.\n"
		"\n"
		"void Xapian::Enquire::set_sort_by_relevance_then_key(KeyMaker *sorter,\n"
		"bool reverse) XAPIAN_NONNULL()\n"
		"Xapian::Enquire::set_sort_by_relevance_then_key Note that with the\n"
		"default BM25 weighting scheme parameters, non- identical documents\n"
		"will rarely have the same weight, so this setting will give very\n"
		"similar results to set_sort_by_relevance(). It becomes more useful\n"
		"with particular BM25 parameter settings (e.g. BM25Weight(1,0,1,0,0))\n"
		"or custom weighting schemes.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"sorter:  The functor to use for generating keys.\n"
		"\n"
		"reverse:  If true, reverses the sort order of the generated keys.\n"
		"Beware that in 1.2.16 and earlier, the sense of this parameter was\n"
		"incorrectly inverted and inconsistent with the other set_sort_by_...\n"
		"methods. This was fixed in 1.2.17, so make that version a minimum\n"
		"requirement if this detail matters to your application. \n"
		""},
	 { "Enquire_set_collapse_key", _wrap_Enquire_set_collapse_key, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Control collapsing of results.\n"
		"\n"
		"void Xapian::Enquire::set_collapse_key(valueno collapse_key, doccount\n"
		"collapse_max=1) Xapian::Enquire::set_collapse_key The MSet returned by\n"
		"get_mset() will have only the \"best\" (at most) collapse_max\n"
		"documents with each particular non-empty value in slot collapse_key\n"
		"(\"best\" being highest ranked - i.e. highest weight or highest\n"
		"sorting key).\n"
		"\n"
		"An example use might be to create a value for each document containing\n"
		"an MD5 hash of the document contents. Then duplicate documents from\n"
		"different sources can be eliminated at search time by collapsing with\n"
		"collapse_max = 1 (it's better to eliminate duplicates at index time,\n"
		"but this may not be always be possible - for example the search may be\n"
		"over more than one Xapian database).\n"
		"\n"
		"Another use is to group matches in a particular category (e.g. you\n"
		"might collapse a mailing list search on the Subject: so that there's\n"
		"only one result per discussion thread). In this case you can use\n"
		"get_collapse_count() to give the user some idea how many other results\n"
		"there are. And if you index the Subject: as a boolean term as well as\n"
		"putting it in a value, you can offer a link to a non-collapsed search\n"
		"restricted to that thread using a boolean filter.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"collapse_key:  value slot to collapse on (default is\n"
		"Xapian::BAD_VALUENO which means no collapsing).\n"
		"\n"
		"collapse_max:  Maximum number of documents with the same key to allow\n"
		"(default: 1). \n"
		""},
	 { "Enquire_set_cutoff", _wrap_Enquire_set_cutoff, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set lower bounds on percentage and/or weight.\n"
		"\n"
		"void Xapian::Enquire::set_cutoff(int percent_threshold, double\n"
		"weight_threshold=0) Xapian::Enquire::set_cutoff\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"percent_threshold:  Lower bound on percentage score\n"
		"\n"
		"weight_threshold:  Lower bound on weight (default: 0)\n"
		"\n"
		"No thresholds are applied by default, and if either threshold is set\n"
		"to 0, then that threshold is disabled. \n"
		""},
	 { "Enquire_add_matchspy", _wrap_Enquire_add_matchspy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a matchspy.\n"
		"\n"
		"void Xapian::Enquire::add_matchspy(MatchSpy *spy) XAPIAN_NONNULL()\n"
		"Xapian::Enquire::add_matchspy This matchspy will be called with some\n"
		"of the documents which match the query, during the match process.\n"
		"Exactly which of the matching documents are passed to it depends on\n"
		"exactly when certain optimisations occur during the match process, but\n"
		"it can be controlled to some extent by setting the checkatleast\n"
		"parameter to  get_mset().\n"
		"\n"
		"In particular, if there are enough matching documents, at least the\n"
		"number specified by checkatleast will be passed to the matchspy. This\n"
		"means that you can force the matchspy to be shown all matching\n"
		"documents by setting checkatleast to the number of documents in the\n"
		"database.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"spy:  The MatchSpy subclass to add. The caller must ensure that this\n"
		"remains valid while the Enquire object remains active, or until\n"
		"clear_matchspies() is called, or else allocate the MatchSpy object\n"
		"with new and then disown it by calling spy->release() before passing\n"
		"it in. \n"
		""},
	 { "Enquire_clear_matchspies", _wrap_Enquire_clear_matchspies, METH_O, "\n"
		"\n"
		"\n"
		"Remove all the matchspies.\n"
		"\n"
		"void Xapian::Enquire::clear_matchspies()\n"
		"Xapian::Enquire::clear_matchspies\n"
		""},
	 { "Enquire_set_time_limit", _wrap_Enquire_set_time_limit, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set a time limit for the match.\n"
		"\n"
		"void Xapian::Enquire::set_time_limit(double time_limit)\n"
		"Xapian::Enquire::set_time_limit Matches with check_at_least set high\n"
		"can take a long time in some cases. You can set a time limit on this,\n"
		"after which check_at_least will be turned off.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"time_limit:  time in seconds after which to disable check_at_least\n"
		"(default: 0.0 which means no time limit)\n"
		"\n"
		"Limitations:\n"
		"\n"
		"This feature is currently supported on platforms which support POSIX\n"
		"interval timers. Interaction with the remote backend when using\n"
		"multiple databases may have bugs. There's not currently a way to force\n"
		"the match to end after a certain time. \n"
		""},
	 { "Enquire_get_mset", _wrap_Enquire_get_mset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Run the query.\n"
		"\n"
		"MSet Xapian::Enquire::get_mset(doccount first, doccount maxitems,\n"
		"const RSet *rset, const MatchDecider *mdecider=NULL) const\n"
		"Xapian::Enquire::get_mset Run the query using the settings in this\n"
		"Enquire object and those passed as parameters to the method, and\n"
		"return a Xapian::MSet object.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"first:  Zero-based index of the first result to return (which supports\n"
		"retrieving pages of results).\n"
		"\n"
		"maxitems:  The maximum number of documents to return.\n"
		"\n"
		"rset:  Documents marked as relevant (default: no documents have been\n"
		"marked as relevant)\n"
		"\n"
		"mdecider:   Xapian::MatchDecider object - this acts as a yes/no filter\n"
		"on documents which match the query. See also Xapian::PostingSource.\n"
		"(default: no Xapian::MatchDecider) \n"
		""},
	 { "Enquire__get_matching_terms_begin", _wrap_Enquire__get_matching_terms_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Iterate query terms matching a document.\n"
		"\n"
		"TermIterator Xapian::Enquire::get_matching_terms_begin(const\n"
		"MSetIterator &it) const Xapian::Enquire::get_matching_terms_begin\n"
		"Convenience overloaded form, taking a Xapian::MSetIterator instead of\n"
		"a Xapian::docid.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"it:   MSetIterator to return matching terms for \n"
		""},
	 { "Enquire__get_matching_terms_end", _wrap_Enquire__get_matching_terms_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to  get_matching_terms_begin().\n"
		"\n"
		"TermIterator Xapian::Enquire::get_matching_terms_end(const\n"
		"MSetIterator &) const noexcept\n"
		"Xapian::Enquire::get_matching_terms_end\n"
		""},
	 { "Enquire_set_expansion_scheme", _wrap_Enquire_set_expansion_scheme, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the weighting scheme to use for expansion.\n"
		"\n"
		"void Xapian::Enquire::set_expansion_scheme(std::string_view\n"
		"eweightname, double expand_k=1.0) const\n"
		"Xapian::Enquire::set_expansion_scheme If you don't call this method,\n"
		"the default is as if you'd used:\n"
		"\n"
		"set_expansion_scheme(\"prob\");\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"eweightname:  A string in lowercase specifying the name of the scheme\n"
		"to be used. The following schemes are currently available: \"bo1\":\n"
		"Bose-Einstein 1 model from the Divergence From Randomness framework.\n"
		"\n"
		"\"prob\" : Probabilistic model (since 1.4.26).\n"
		"\n"
		"\"trad\" : Deprecated alias for \"prob\".\n"
		"\n"
		"expand_k:  Parameter k for probabilistic query expansion. A default\n"
		"value of 1.0 is used if none is specified. \n"
		""},
	 { "Enquire_get_eset", _wrap_Enquire_get_eset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Perform query expansion.\n"
		"\n"
		"ESet Xapian::Enquire::get_eset(termcount maxitems, const RSet &rset,\n"
		"const ExpandDecider *edecider) const Xapian::Enquire::get_eset Perform\n"
		"query expansion using a Xapian::RSet indicating some documents which\n"
		"are relevant (typically based on the user marking results or similar).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"maxitems:  The maximum number of terms to return.\n"
		"\n"
		"rset:  Documents marked as relevant.\n"
		"\n"
		"edecider:   Xapian::ExpandDecider object - this acts as a yes/no\n"
		"filter on terms which are being considered.\n"
		"\n"
		"Xapian::ESet object containing a list of terms with weights. \n"
		""},
	 { "Enquire___str__", _wrap_Enquire___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::Enquire::get_description() const\n"
		"Xapian::Enquire::get_description\n"
		""},
	 { "Enquire_swigregister", Enquire_swigregister, METH_O, NULL},
	 { "Enquire_swiginit", Enquire_swiginit, METH_VARARGS, NULL},
	 { "new_ExpandDecider", _wrap_new_ExpandDecider, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::ExpandDecider::ExpandDecider()\n"
		"Xapian::ExpandDecider::ExpandDecider\n"
		""},
	 { "ExpandDecider___call__", _wrap_ExpandDecider___call__, METH_VARARGS, NULL},
	 { "delete_ExpandDecider", _wrap_delete_ExpandDecider, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::ExpandDecider::~ExpandDecider()\n"
		"Xapian::ExpandDecider::~ExpandDecider\n"
		""},
	 { "ExpandDecider_release", _wrap_ExpandDecider_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const ExpandDecider * Xapian::ExpandDecider::release() const\n"
		"Xapian::ExpandDecider::release You can transfer ownership of a\n"
		"dynamically allocated ExpandDecider object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_ExpandDecider", _wrap_disown_ExpandDecider, METH_O, NULL},
	 { "ExpandDecider_swigregister", ExpandDecider_swigregister, METH_O, NULL},
	 { "ExpandDecider_swiginit", ExpandDecider_swiginit, METH_VARARGS, NULL},
	 { "new_ExpandDeciderAnd", _wrap_new_ExpandDeciderAnd, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compatibility method.\n"
		"\n"
		"Xapian::ExpandDeciderAnd::ExpandDeciderAnd(const ExpandDecider\n"
		"*first_, const ExpandDecider *second_)\n"
		"Xapian::ExpandDeciderAnd::ExpandDeciderAnd\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"first_:  First ExpandDecider object to test with.\n"
		"\n"
		"second_:   ExpandDecider object to test with if first_ accepts. \n"
		""},
	 { "delete_ExpandDeciderAnd", _wrap_delete_ExpandDeciderAnd, METH_O, NULL},
	 { "ExpandDeciderAnd_swigregister", ExpandDeciderAnd_swigregister, METH_O, NULL},
	 { "ExpandDeciderAnd_swiginit", ExpandDeciderAnd_swiginit, METH_VARARGS, NULL},
	 { "new_ExpandDeciderFilterPrefix", _wrap_new_ExpandDeciderFilterPrefix, METH_O, "\n"
		"\n"
		"\n"
		"The parameter specify the prefix of terms to be retained.\n"
		"\n"
		"Xapian::ExpandDeciderFilterPrefix::ExpandDeciderFilterPrefix(const\n"
		"std::string &prefix_)\n"
		"Xapian::ExpandDeciderFilterPrefix::ExpandDeciderFilterPrefix\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix_:  restrict terms to the particular prefix_ \n"
		""},
	 { "delete_ExpandDeciderFilterPrefix", _wrap_delete_ExpandDeciderFilterPrefix, METH_O, NULL},
	 { "ExpandDeciderFilterPrefix_swigregister", ExpandDeciderFilterPrefix_swigregister, METH_O, NULL},
	 { "ExpandDeciderFilterPrefix_swiginit", ExpandDeciderFilterPrefix_swiginit, METH_VARARGS, NULL},
	 { "new_KeyMaker", _wrap_new_KeyMaker, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::KeyMaker::KeyMaker() Xapian::KeyMaker::KeyMaker\n"
		""},
	 { "KeyMaker___call__", _wrap_KeyMaker___call__, METH_VARARGS, NULL},
	 { "delete_KeyMaker", _wrap_delete_KeyMaker, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::KeyMaker::~KeyMaker() Xapian::KeyMaker::~KeyMaker\n"
		""},
	 { "KeyMaker_name", _wrap_KeyMaker_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the name of this KeyMaker.\n"
		"\n"
		"virtual std::string Xapian::KeyMaker::name() const\n"
		"Xapian::KeyMaker::name This name is used by the remote backend. It is\n"
		"passed with the serialised parameters to the remote server so that it\n"
		"knows which class to create.\n"
		"\n"
		"Return the full namespace-qualified name of your class here - if your\n"
		"class is called MyApp::FooKeyMaker, return \"MyApp::FooKeyMaker\" from\n"
		"this method.\n"
		"\n"
		"If you don't want to support the remote backend in your KeyMaker, you\n"
		"can use the default implementation which simply throws\n"
		"Xapian::UnimplementedError. \n"
		""},
	 { "KeyMaker_release", _wrap_KeyMaker_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const KeyMaker * Xapian::KeyMaker::release() const\n"
		"Xapian::KeyMaker::release You can transfer ownership of a dynamically\n"
		"allocated KeyMaker object to Xapian by calling release() and then\n"
		"passing the object to a Xapian method. Xapian will arrange to delete\n"
		"the object once it is no longer required. \n"
		""},
	 { "disown_KeyMaker", _wrap_disown_KeyMaker, METH_O, NULL},
	 { "KeyMaker_swigregister", KeyMaker_swigregister, METH_O, NULL},
	 { "KeyMaker_swiginit", KeyMaker_swiginit, METH_VARARGS, NULL},
	 { "new_MultiValueKeyMaker", _wrap_new_MultiValueKeyMaker, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a MultiValueKeyMaker from a pair of iterators.\n"
		"\n"
		"Xapian::MultiValueKeyMaker::MultiValueKeyMaker(Iterator begin,\n"
		"Iterator end) Xapian::MultiValueKeyMaker::MultiValueKeyMaker The\n"
		"iterators must be a begin/end pair returning Xapian::valueno (or a\n"
		"compatible type) when dereferenced. \n"
		""},
	 { "MultiValueKeyMaker_add_value", _wrap_MultiValueKeyMaker_add_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a value slot to the list to build a key from.\n"
		"\n"
		"void Xapian::MultiValueKeyMaker::add_value(Xapian::valueno slot, bool\n"
		"reverse=false, std::string_view defvalue={})\n"
		"Xapian::MultiValueKeyMaker::add_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to add\n"
		"\n"
		"reverse:  Adjust values from this slot to reverse their sort order\n"
		"(default: false)\n"
		"\n"
		"defvalue:  Value to use for documents which don't have a value set in\n"
		"this slot (default: empty). This can be used to make such documents\n"
		"sort after all others by passing get_value_upper_bound(slot) + \"x\"\n"
		"this is guaranteed to be greater than any value in this slot. \n"
		""},
	 { "delete_MultiValueKeyMaker", _wrap_delete_MultiValueKeyMaker, METH_O, NULL},
	 { "MultiValueKeyMaker_swigregister", MultiValueKeyMaker_swigregister, METH_O, NULL},
	 { "MultiValueKeyMaker_swiginit", MultiValueKeyMaker_swiginit, METH_VARARGS, NULL},
	 { "new_Stopper", _wrap_new_Stopper, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::Stopper::Stopper() Xapian::Stopper::Stopper\n"
		""},
	 { "Stopper___call__", _wrap_Stopper___call__, METH_VARARGS, NULL},
	 { "delete_Stopper", _wrap_delete_Stopper, METH_O, "\n"
		"\n"
		"\n"
		"Class has virtual methods, so provide a virtual destructor.\n"
		"\n"
		"virtual Xapian::Stopper::~Stopper() Xapian::Stopper::~Stopper\n"
		""},
	 { "Stopper___str__", _wrap_Stopper___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::Stopper::get_description() const\n"
		"Xapian::Stopper::get_description\n"
		""},
	 { "Stopper_release", _wrap_Stopper_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const Stopper * Xapian::Stopper::release() const\n"
		"Xapian::Stopper::release You can transfer ownership of a dynamically\n"
		"allocated Stopper object to Xapian by calling release() and then\n"
		"passing the object to a Xapian method. Xapian will arrange to delete\n"
		"the object once it is no longer required. \n"
		""},
	 { "disown_Stopper", _wrap_disown_Stopper, METH_O, NULL},
	 { "Stopper_swigregister", Stopper_swigregister, METH_O, NULL},
	 { "Stopper_swiginit", Stopper_swiginit, METH_VARARGS, NULL},
	 { "SimpleStopper_add", _wrap_SimpleStopper_add, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a single stop word.\n"
		"\n"
		"void Xapian::SimpleStopper::add(const std::string &word)\n"
		"Xapian::SimpleStopper::add\n"
		""},
	 { "new_SimpleStopper", _wrap_new_SimpleStopper, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Initialise from a pair of iterators.\n"
		"\n"
		"Xapian::SimpleStopper::SimpleStopper(Iterator begin, Iterator end)\n"
		"Xapian::SimpleStopper::SimpleStopper  Xapian includes stopword list\n"
		"files for many languages. You can initialise from a file like so:\n"
		"\n"
		"In bindings for other languages it isn't possible to pass a C++\n"
		"iterator pair, so instead this constructor is wrapped to allow passing\n"
		"a filename. \n"
		""},
	 { "delete_SimpleStopper", _wrap_delete_SimpleStopper, METH_O, NULL},
	 { "SimpleStopper_swigregister", SimpleStopper_swigregister, METH_O, NULL},
	 { "SimpleStopper_swiginit", SimpleStopper_swiginit, METH_VARARGS, NULL},
	 { "new_RangeProcessor", _wrap_new_RangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::RangeProcessor::RangeProcessor(Xapian::valueno slot_,\n"
		"std::string_view str_={}, unsigned flags_=0)\n"
		"Xapian::RangeProcessor::RangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  Which value slot to generate ranges over.\n"
		"\n"
		"str_:  A string to look for to recognise values as belonging to this\n"
		"range (as a prefix by default, or as a suffix if flags\n"
		"Xapian::RP_SUFFIX is specified).\n"
		"\n"
		"flags_:  Zero or more of the following flags, combined with bitwise-or\n"
		"(| in C++): Xapian::RP_SUFFIX - require str_ as a suffix instead of a\n"
		"prefix.\n"
		"\n"
		"Xapian::RP_REPEATED - optionally allow str_ on both ends of the range,\n"
		"or only on the non-empty end - e.g. $1..$10, ..$10, 5m..50m, or 5m...\n"
		"By default a prefix is only checked for on the start (e.g.\n"
		"date:1/1/1980..31/12/1989 or date:..31/12/1989), and a suffix only on\n"
		"the end (e.g. 2..12kg or 2..kg). \n"
		""},
	 { "delete_RangeProcessor", _wrap_delete_RangeProcessor, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::RangeProcessor::~RangeProcessor()\n"
		"Xapian::RangeProcessor::~RangeProcessor\n"
		""},
	 { "RangeProcessor_check_range", _wrap_RangeProcessor_check_range, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check prefix/suffix on range.\n"
		"\n"
		"Xapian::Query Xapian::RangeProcessor::check_range(const std::string\n"
		"&b, const std::string &e) Xapian::RangeProcessor::check_range If they\n"
		"match, remove the prefix/suffix and then call operator()() to try to\n"
		"handle the range. \n"
		""},
	 { "RangeProcessor___call__", _wrap_RangeProcessor___call__, METH_VARARGS, NULL},
	 { "RangeProcessor_release", _wrap_RangeProcessor_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const RangeProcessor * Xapian::RangeProcessor::release() const\n"
		"Xapian::RangeProcessor::release You can transfer ownership of a\n"
		"dynamically allocated RangeProcessor object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_RangeProcessor", _wrap_disown_RangeProcessor, METH_O, NULL},
	 { "RangeProcessor_swigregister", RangeProcessor_swigregister, METH_O, NULL},
	 { "RangeProcessor_swiginit", RangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_DateRangeProcessor", _wrap_new_DateRangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::DateRangeProcessor::DateRangeProcessor(Xapian::valueno slot_,\n"
		"std::string_view str_, unsigned flags_=0, int epoch_year_=1970)\n"
		"Xapian::DateRangeProcessor::DateRangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot number to query.\n"
		"\n"
		"str_:  A prefix or suffix string to look for to recognise values as\n"
		"belonging to this date range ( flags_ determines whether this is a\n"
		"prefix or suffix).\n"
		"\n"
		"flags_:  Zero or more of the following flags, combined with bitwise-\n"
		"or: Xapian::RP_SUFFIX - require str_ as a suffix instead of a prefix.\n"
		"\n"
		"Xapian::RP_REPEATED - optionally allow str_ on both ends of the range\n"
		"- e.g. $1..$10 or 5m..50m. By default a prefix is only checked for on\n"
		"the start (e.g. date:1/1/1980..31/12/1989), and a suffix only on the\n"
		"end (e.g. 2..12kg).\n"
		"\n"
		"Xapian::RP_DATE_PREFER_MDY - interpret ambiguous dates as\n"
		"month/day/year rather than day/month/year.\n"
		"\n"
		"epoch_year_:  Year to use as the epoch for dates with 2 digit years\n"
		"(default: 1970, so 1/1/69 is 2069 while 1/1/70 is 1970).\n"
		"\n"
		"The string supplied in str_ is used by operator() to decide whether\n"
		"the pair of strings supplied to it constitute a valid range. If\n"
		"prefix_ is true, the first value in a range must begin with str_ (and\n"
		"the second value may optionally begin with str_); if prefix_ is false,\n"
		"the second value in a range must end with str_ (and the first value\n"
		"may optionally end with str_).\n"
		"\n"
		"If str_ is empty then no prefix or suffix is checked for (and\n"
		"Xapian::RP_SUFFIX and Xapian::RP_REPEATED are irrelevant) - anything\n"
		"which looks like a date range will be processed. \n"
		""},
	 { "delete_DateRangeProcessor", _wrap_delete_DateRangeProcessor, METH_O, NULL},
	 { "DateRangeProcessor_swigregister", DateRangeProcessor_swigregister, METH_O, NULL},
	 { "DateRangeProcessor_swiginit", DateRangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_NumberRangeProcessor", _wrap_new_NumberRangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::NumberRangeProcessor::NumberRangeProcessor(Xapian::valueno\n"
		"slot_, std::string_view str_={}, unsigned flags_=0)\n"
		"Xapian::NumberRangeProcessor::NumberRangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot number to query.\n"
		"\n"
		"str_:  A string to look for to recognise values as belonging to this\n"
		"numeric range.\n"
		"\n"
		"flags_:  Zero or more of the following flags, combined with bitwise-\n"
		"or: Xapian::RP_SUFFIX - require str_ as a suffix instead of a prefix.\n"
		"\n"
		"Xapian::RP_REPEATED - optionally allow str_ on both ends of the range\n"
		"- e.g. $1..$10 or 5m..50m. By default a prefix is only checked for on\n"
		"the start (e.g. date:1/1/1980..31/12/1989), and a suffix only on the\n"
		"end (e.g. 2..12kg).\n"
		"\n"
		"The string supplied in str_ is used by operator() to decide whether\n"
		"the pair of strings supplied to it constitute a valid range. If\n"
		"prefix_ is true, the first value in a range must begin with str_ (and\n"
		"the second value may optionally begin with str_); if prefix_ is false,\n"
		"the second value in a range must end with str_ (and the first value\n"
		"may optionally end with str_).\n"
		"\n"
		"If str_ is empty, the setting of prefix_ is irrelevant, and no special\n"
		"strings are required at the start or end of the strings defining the\n"
		"range.\n"
		"\n"
		"The remainder of both strings defining the endpoints must be valid\n"
		"floating point numbers. (FIXME: define format recognised).\n"
		"\n"
		"For example, if str_ is \"$\" and prefix_ is true, and the range\n"
		"processor has been added to the queryparser, the queryparser will\n"
		"accept \"$10..50\" or \"$10..$50\", but not \"10..50\" or \"10..$50\"\n"
		"as valid ranges. If str_ is \"kg\" and prefix_ is false, the\n"
		"queryparser will accept \"10..50kg\" or \"10kg..50kg\", but not\n"
		"\"10..50\" or \"10kg..50\" as valid ranges. \n"
		""},
	 { "delete_NumberRangeProcessor", _wrap_delete_NumberRangeProcessor, METH_O, NULL},
	 { "NumberRangeProcessor_swigregister", NumberRangeProcessor_swigregister, METH_O, NULL},
	 { "NumberRangeProcessor_swiginit", NumberRangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_UnitRangeProcessor", _wrap_new_UnitRangeProcessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Constructor.\n"
		"\n"
		"Xapian::UnitRangeProcessor::UnitRangeProcessor(Xapian::valueno slot_,\n"
		"std::string_view str_={})\n"
		"Xapian::UnitRangeProcessor::UnitRangeProcessor\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot number to query.\n"
		"\n"
		"str_:  A string to look for to recognise values as belonging to this\n"
		"numeric range.\n"
		"\n"
		"The string supplied in str_ is the prefix plus \":\" that defines the\n"
		"field upon which the range query is performed.\n"
		"\n"
		"For example, if str_ is \"size:\", and the range processor has been\n"
		"added to the queryparser, the queryparser will accept \"size:3K..10K\"\n"
		"as a valid range. \n"
		""},
	 { "delete_UnitRangeProcessor", _wrap_delete_UnitRangeProcessor, METH_O, NULL},
	 { "UnitRangeProcessor_swigregister", UnitRangeProcessor_swigregister, METH_O, NULL},
	 { "UnitRangeProcessor_swiginit", UnitRangeProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_FieldProcessor", _wrap_new_FieldProcessor, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::FieldProcessor::FieldProcessor()\n"
		"Xapian::FieldProcessor::FieldProcessor\n"
		""},
	 { "delete_FieldProcessor", _wrap_delete_FieldProcessor, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::FieldProcessor::~FieldProcessor()\n"
		"Xapian::FieldProcessor::~FieldProcessor\n"
		""},
	 { "FieldProcessor___call__", _wrap_FieldProcessor___call__, METH_VARARGS, NULL},
	 { "FieldProcessor_release", _wrap_FieldProcessor_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const FieldProcessor * Xapian::FieldProcessor::release() const\n"
		"Xapian::FieldProcessor::release You can transfer ownership of a\n"
		"dynamically allocated FieldProcessor object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_FieldProcessor", _wrap_disown_FieldProcessor, METH_O, NULL},
	 { "FieldProcessor_swigregister", FieldProcessor_swigregister, METH_O, NULL},
	 { "FieldProcessor_swiginit", FieldProcessor_swiginit, METH_VARARGS, NULL},
	 { "new_QueryParser", _wrap_new_QueryParser, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor.\n"
		"\n"
		"Xapian::QueryParser::QueryParser() Xapian::QueryParser::QueryParser\n"
		""},
	 { "delete_QueryParser", _wrap_delete_QueryParser, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"Xapian::QueryParser::~QueryParser()\n"
		"Xapian::QueryParser::~QueryParser\n"
		""},
	 { "QueryParser_set_stemmer", _wrap_QueryParser_set_stemmer, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stemmer.\n"
		"\n"
		"void Xapian::QueryParser::set_stemmer(const Xapian::Stem &stemmer)\n"
		"Xapian::QueryParser::set_stemmer This sets the stemming algorithm\n"
		"which will be used by the query parser. The stemming algorithm will be\n"
		"used according to the stemming strategy set by\n"
		"set_stemming_strategy(). As of 1.3.1, this defaults to STEM_SOME, but\n"
		"in earlier versions the default was STEM_NONE. If you want to work\n"
		"with older versions, you should explicitly set a stemming strategy as\n"
		"well as setting a stemmer, otherwise your stemmer won't actually be\n"
		"used.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stemmer:  The Xapian::Stem object to set. \n"
		""},
	 { "QueryParser_set_stemming_strategy", _wrap_QueryParser_set_stemming_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stemming strategy.\n"
		"\n"
		"void Xapian::QueryParser::set_stemming_strategy(stem_strategy\n"
		"strategy) Xapian::QueryParser::set_stemming_strategy This controls how\n"
		"the query parser will apply the stemming algorithm. Note that the\n"
		"stemming algorithm is only applied to words in free-text fields -\n"
		"boolean filter terms are never stemmed.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STEM_NONE: Don't\n"
		"perform any stemming. (default in Xapian <= 1.3.0)\n"
		"\n"
		"STEM_SOME: Stem all terms except for those which start with a capital\n"
		"letter, or are followed by certain characters (currently: (/@<>=*[{\"\n"
		"), or are used with operators which need positional information.\n"
		"Stemmed terms are prefixed with 'Z'. (default in Xapian >= 1.3.1)\n"
		"\n"
		"STEM_SOME_FULL_POS: Like STEM_SOME but also stems terms used with\n"
		"operators which need positional information. Added in Xapian 1.4.8.\n"
		"\n"
		"STEM_ALL: Stem all terms (note: no 'Z' prefix is added).\n"
		"\n"
		"STEM_ALL_Z: Stem all terms (note: 'Z' prefix is added). (new in Xapian\n"
		"1.2.11 and 1.3.1) \n"
		""},
	 { "QueryParser_set_stopper", _wrap_QueryParser_set_stopper, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stopper.\n"
		"\n"
		"void Xapian::QueryParser::set_stopper(const Stopper *stop=NULL)\n"
		"Xapian::QueryParser::set_stopper\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"stop:  The Stopper object to set (default NULL, which means no\n"
		"stopwords). \n"
		""},
	 { "QueryParser_set_stopper_strategy", _wrap_QueryParser_set_stopper_strategy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the stopper strategy.\n"
		"\n"
		"void Xapian::QueryParser::set_stopper_strategy(stop_strategy strategy)\n"
		"Xapian::QueryParser::set_stopper_strategy This method controls how the\n"
		"stopper is used.\n"
		"\n"
		"You need to also call  set_stopper() for this to have any effect.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"strategy:  The strategy to use - possible values are: STOP_NONE: Don't\n"
		"use the stopper.\n"
		"\n"
		"STOP_ALL: If a word is identified as a stop word, skip it completely.\n"
		"This makes some queries less useful (e.g. \"to be or not to be that is\n"
		"the question\" would become a search for just question if the other\n"
		"words were all stopwords). If you index with STOP_ALL you should use\n"
		"it when parsing queries too.\n"
		"\n"
		"STOP_STEMMED: If a word is identified as a stop word, assume it was\n"
		"still indexed unstemmed and don't treat it as a stopword in contexts\n"
		"where we would use the unstemmed form (for example, phrase searches,\n"
		"ADJ, NEAR). (This is the default mode).\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "QueryParser_set_default_op", _wrap_QueryParser_set_default_op, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the default operator.\n"
		"\n"
		"void Xapian::QueryParser::set_default_op(Query::op default_op)\n"
		"Xapian::QueryParser::set_default_op\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"default_op:  The operator to use to combine non-filter query items\n"
		"when no explicit operator is used.\n"
		"\n"
		"So for example, 'weather forecast' is parsed as if it were 'weather OR\n"
		"forecast' by default.\n"
		"\n"
		"The most useful values for this are OP_OR (the default) and OP_AND.\n"
		"OP_NEAR, OP_PHRASE, OP_ELITE_SET, OP_SYNONYM and OP_MAX are also\n"
		"permitted. Passing other values will result in InvalidArgumentError\n"
		"being thrown. \n"
		""},
	 { "QueryParser_get_default_op", _wrap_QueryParser_get_default_op, METH_O, "\n"
		"\n"
		"\n"
		"Get the current default operator.\n"
		"\n"
		"Query::op Xapian::QueryParser::get_default_op() const\n"
		"Xapian::QueryParser::get_default_op\n"
		""},
	 { "QueryParser_set_database", _wrap_QueryParser_set_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify the database being searched.\n"
		"\n"
		"void Xapian::QueryParser::set_database(const Database &db)\n"
		"Xapian::QueryParser::set_database\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database to use for spelling correction\n"
		"(FLAG_SPELLING_CORRECTION), and synonyms (FLAG_SYNONYM,\n"
		"FLAG_AUTO_SYNONYMS, and FLAG_AUTO_MULTIWORD_SYNONYMS). \n"
		""},
	 { "QueryParser_set_max_expansion", _wrap_QueryParser_set_max_expansion, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify the maximum expansion of a wildcard and/or partial and/or\n"
		"fuzzy term.\n"
		"\n"
		"void Xapian::QueryParser::set_max_expansion(Xapian::termcount\n"
		"max_expansion, int max_type=Xapian::Query::WILDCARD_LIMIT_ERROR,\n"
		"unsigned flags=FLAG_WILDCARD|FLAG_PARTIAL|FLAG_FUZZY)\n"
		"Xapian::QueryParser::set_max_expansion Note: you must also set\n"
		"FLAG_WILDCARD and/or FLAG_PARTIAL and/or FLAG_FUZZY in the flags\n"
		"parameter to  parse_query() for this setting to have anything to\n"
		"affect.\n"
		"\n"
		"If you don't call this method, the default settings are no limit on\n"
		"wildcard and fuzzy expansion, and partial terms expanding to the most\n"
		"frequent 100 terms - i.e. as if you'd called:\n"
		"\n"
		"set_max_expansion(0); set_max_expansion(100,\n"
		"Xapian::Query::WILDCARD_LIMIT_MOST_FREQUENT,\n"
		"Xapian::QueryParser::FLAG_PARTIAL);\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_expansion:  The maximum number of terms each wildcard in the query\n"
		"can expand to, or 0 for no limit (which is the default).\n"
		"\n"
		"max_type:    Xapian::Query::WILDCARD_LIMIT_ERROR,\n"
		"Xapian::Query::WILDCARD_LIMIT_FIRST or\n"
		"Xapian::Query::WILDCARD_LIMIT_MOST_FREQUENT (default:\n"
		"Xapian::Query::WILDCARD_LIMIT_ERROR).\n"
		"\n"
		"flags:  What to set the limit for (default:\n"
		"FLAG_WILDCARD|FLAG_PARTIAL|FLAG_FUZZY, setting the limit for all\n"
		"types).\n"
		"\n"
		"1.3.3 \n"
		""},
	 { "QueryParser_set_min_wildcard_prefix", _wrap_QueryParser_set_min_wildcard_prefix, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify minimum length for fixed initial portion in wildcard patterns.\n"
		"\n"
		"void Xapian::QueryParser::set_min_wildcard_prefix(unsigned\n"
		"min_prefix_len, unsigned flags=FLAG_WILDCARD|FLAG_PARTIAL)\n"
		"Xapian::QueryParser::set_min_wildcard_prefix It can be desirable for\n"
		"performance reasons to restrict use of wildcards to patterns with a\n"
		"fixed initial portion, so this method provides a way to specify a\n"
		"minimum length. A wildcard pattern with a shorter (or no) fixed\n"
		"initial portion will result in Xapian::QueryParser being thrown. The\n"
		"default minimum length is 0.\n"
		"\n"
		"It also provides a way to specify the minimum length of a word to\n"
		"expand for partial matching (see FLAG_PARTIAL). In this case a shorter\n"
		"word at the end of the query simply result in no partial matching. The\n"
		"default minimum length for this case is 2 (since 2.0.0 - in earlier\n"
		"versions it was effectively 0).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"min_prefix_len:  Minimum length of fixed initial portion in Unicode\n"
		"characters.\n"
		"\n"
		"flags:  What to set the minimum length for (default:\n"
		"FLAG_WILDCARD|FLAG_PARTIAL, setting the limit for both wildcards and\n"
		"partial terms).\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "QueryParser_parse_query", _wrap_QueryParser_parse_query, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Parse a query.\n"
		"\n"
		"Query Xapian::QueryParser::parse_query(std::string_view query_string,\n"
		"unsigned flags=FLAG_DEFAULT, std::string_view default_prefix={})\n"
		"Xapian::QueryParser::parse_query\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"query_string:  A free-text query as entered by a user\n"
		"\n"
		"flags:  Zero or more QueryParser::feature_flag specifying what\n"
		"features the QueryParser should support. Combine multiple values with\n"
		"bitwise-or (|) (default FLAG_DEFAULT).\n"
		"\n"
		"default_prefix:  The default term prefix to use (default none). For\n"
		"example, you can pass \"A\" when parsing an \"Author\" field.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"If:  the query string can't be parsed, then Xapian::QueryParserError\n"
		"is thrown. You can get an English error message to report to the user\n"
		"by catching it and calling get_msg() on the caught exception. The\n"
		"current possible values (in case you want to translate them) are:\n"
		"\n"
		"Unknown range operation\n"
		"\n"
		"parse error\n"
		"\n"
		"Syntax: <expression> AND <expression>\n"
		"\n"
		"Syntax: <expression> AND NOT <expression>\n"
		"\n"
		"Syntax: <expression> NOT <expression>\n"
		"\n"
		"Syntax: <expression> OR <expression>\n"
		"\n"
		"Syntax: <expression> XOR <expression> \n"
		""},
	 { "QueryParser_add_prefix", _wrap_QueryParser_add_prefix, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a FieldProcessor.\n"
		"\n"
		"void Xapian::QueryParser::add_prefix(std::string_view field,\n"
		"Xapian::FieldProcessor *proc) Xapian::QueryParser::add_prefix\n"
		""},
	 { "QueryParser_add_boolean_prefix", _wrap_QueryParser_add_boolean_prefix, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a FieldProcessor for a boolean prefix.\n"
		"\n"
		"void Xapian::QueryParser::add_boolean_prefix(std::string_view field,\n"
		"Xapian::FieldProcessor *proc, bool exclusive)\n"
		"Xapian::QueryParser::add_boolean_prefix This is an older version of\n"
		"this method - use the version with the grouping parameter in\n"
		"preference to this one. \n"
		""},
	 { "QueryParser__stoplist_begin", _wrap_QueryParser__stoplist_begin, METH_O, "\n"
		"\n"
		"\n"
		"Begin iterator over terms omitted from the query as stopwords.\n"
		"\n"
		"TermIterator Xapian::QueryParser::stoplist_begin() const\n"
		"Xapian::QueryParser::stoplist_begin\n"
		""},
	 { "QueryParser__stoplist_end", _wrap_QueryParser__stoplist_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator over terms omitted from the query as stopwords.\n"
		"\n"
		"TermIterator Xapian::QueryParser::stoplist_end() const noexcept\n"
		"Xapian::QueryParser::stoplist_end\n"
		""},
	 { "QueryParser__unstem_begin", _wrap_QueryParser__unstem_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Begin iterator over unstemmed forms of the given stemmed query term.\n"
		"\n"
		"TermIterator Xapian::QueryParser::unstem_begin(std::string_view term)\n"
		"const Xapian::QueryParser::unstem_begin\n"
		""},
	 { "QueryParser__unstem_end", _wrap_QueryParser__unstem_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator over unstemmed forms of the given stemmed query term.\n"
		"\n"
		"TermIterator Xapian::QueryParser::unstem_end(std::string_view) const\n"
		"noexcept Xapian::QueryParser::unstem_end\n"
		""},
	 { "QueryParser_add_rangeprocessor", _wrap_QueryParser_add_rangeprocessor, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Register a RangeProcessor.\n"
		"\n"
		"void Xapian::QueryParser::add_rangeprocessor(Xapian::RangeProcessor\n"
		"*range_proc, const std::string *grouping=NULL)\n"
		"Xapian::QueryParser::add_rangeprocessor\n"
		""},
	 { "QueryParser_get_corrected_query_string", _wrap_QueryParser_get_corrected_query_string, METH_O, "\n"
		"\n"
		"\n"
		"Get the spelling-corrected query string.\n"
		"\n"
		"std::string Xapian::QueryParser::get_corrected_query_string() const\n"
		"Xapian::QueryParser::get_corrected_query_string This will only be set\n"
		"if FLAG_SPELLING_CORRECTION is specified when\n"
		"QueryParser::parse_query() was last called.\n"
		"\n"
		"If there were no corrections, an empty string is returned. \n"
		""},
	 { "QueryParser___str__", _wrap_QueryParser___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::QueryParser::get_description() const\n"
		"Xapian::QueryParser::get_description\n"
		""},
	 { "QueryParser_swigregister", QueryParser_swigregister, METH_O, NULL},
	 { "QueryParser_swiginit", QueryParser_swiginit, METH_VARARGS, NULL},
	 { "sortable_serialise", _wrap_sortable_serialise, METH_O, NULL},
	 { "sortable_unserialise", _wrap_sortable_unserialise, METH_O, NULL},
	 { "new_ValueSetMatchDecider", _wrap_new_ValueSetMatchDecider, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a ValueSetMatchDecider.\n"
		"\n"
		"Xapian::ValueSetMatchDecider::ValueSetMatchDecider(Xapian::valueno\n"
		"slot, bool inclusive_)\n"
		"Xapian::ValueSetMatchDecider::ValueSetMatchDecider\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot number to look in.\n"
		"\n"
		"inclusive_:  If true, match decider accepts documents which have a\n"
		"value in the specified slot which is a member of the test set; if\n"
		"false, match decider accepts documents which do not have a value in\n"
		"the specified slot. \n"
		""},
	 { "ValueSetMatchDecider_add_value", _wrap_ValueSetMatchDecider_add_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a value to the test set.\n"
		"\n"
		"void Xapian::ValueSetMatchDecider::add_value(const std::string &value)\n"
		"Xapian::ValueSetMatchDecider::add_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"value:  The value to add to the test set. \n"
		""},
	 { "ValueSetMatchDecider_remove_value", _wrap_ValueSetMatchDecider_remove_value, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a value from the test set.\n"
		"\n"
		"void Xapian::ValueSetMatchDecider::remove_value(const std::string\n"
		"&value) Xapian::ValueSetMatchDecider::remove_value\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"value:  The value to remove from the test set. \n"
		""},
	 { "delete_ValueSetMatchDecider", _wrap_delete_ValueSetMatchDecider, METH_O, NULL},
	 { "ValueSetMatchDecider_swigregister", ValueSetMatchDecider_swigregister, METH_O, NULL},
	 { "ValueSetMatchDecider_swiginit", ValueSetMatchDecider_swiginit, METH_VARARGS, NULL},
	 { "delete_Weight", _wrap_delete_Weight, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::Weight::~Weight() Xapian::Weight::~Weight\n"
		""},
	 { "Weight_name", _wrap_Weight_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the name of this weighting scheme, e.g.\n"
		"\n"
		"virtual std::string Xapian::Weight::name() const Xapian::Weight::name\n"
		"\"bm25+\".\n"
		"\n"
		"This is the name that the weighting scheme gets registered under when\n"
		"passed to Xapian:Registry::register_weighting_scheme().\n"
		"\n"
		"As a result:\n"
		"\n"
		"this is the name that needs to be used in Weight::create() to create a\n"
		"Weight object from a human-readable string description.\n"
		"\n"
		"it is also used by the remote backend where it is sent (along with the\n"
		"serialised parameters) to the remote server so that it knows which\n"
		"class to create.\n"
		"\n"
		"For 1.4.x and earlier we recommended returning the full namespace-\n"
		"qualified name of your class here, but now we recommend returning a\n"
		"just the name in lower case, e.g. \"foo\" instead of \"FooWeight\",\n"
		"\"bm25+\" instead of \"Xapian::BM25PlusWeight\".\n"
		"\n"
		"If you don't want to support creation via Weight::create() or the\n"
		"remote backend, you can use the default implementation which simply\n"
		"returns an empty string. \n"
		""},
	 { "Weight_get_sumpart", _wrap_Weight_get_sumpart, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the weight contribution for this object's term to a\n"
		"document.\n"
		"\n"
		"virtual double Xapian::Weight::get_sumpart(Xapian::termcount wdf,\n"
		"Xapian::termcount doclen, Xapian::termcount uniqterms,\n"
		"Xapian::termcount wdfdocmax) const =0 Xapian::Weight::get_sumpart The\n"
		"parameters give information about the document which may be used in\n"
		"the calculations:\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wdf:  The within document frequency of the term in the document. You\n"
		"need to call need_stat(WDF) if you use this value.\n"
		"\n"
		"doclen:  The document's length (unnormalised). You need to call\n"
		"need_stat(DOC_LENGTH) if you use this value.\n"
		"\n"
		"uniqterms:  Number of unique terms in the document. You need to call\n"
		"need_stat(UNIQUE_TERMS) if you use this value.\n"
		"\n"
		"wdfdocmax:  Maximum wdf value in the document. You need to call\n"
		"need_stat(WDF_DOC_MAX) if you use this value.\n"
		"\n"
		"You can rely of wdf <= doclen if you call both need_stat(WDF) and\n"
		"need_stat(DOC_LENGTH) - this is trivially true for terms, but Xapian\n"
		"also ensure it's true for OP_SYNONYM, where the wdf is approximated.\n"
		"\n"
		"The wdfdocmax parameter was added in Xapian 2.0.0. \n"
		""},
	 { "Weight_get_maxpart", _wrap_Weight_get_maxpart, METH_O, "\n"
		"\n"
		"\n"
		"Return an upper bound on what get_sumpart() can return for any\n"
		"document.\n"
		"\n"
		"virtual double Xapian::Weight::get_maxpart() const =0\n"
		"Xapian::Weight::get_maxpart This information is used by the matcher to\n"
		"perform various optimisations, so strive to make the bound as tight as\n"
		"possible. \n"
		""},
	 { "Weight_get_sumextra", _wrap_Weight_get_sumextra, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the term-independent weight component for a document.\n"
		"\n"
		"virtual double Xapian::Weight::get_sumextra(Xapian::termcount doclen,\n"
		"Xapian::termcount uniqterms, Xapian::termcount wdfdocmax) const\n"
		"Xapian::Weight::get_sumextra The default implementation always returns\n"
		"0 (in Xapian < 2.0.0 this was a pure virtual method).\n"
		"\n"
		"The parameter gives information about the document which may be used\n"
		"in the calculations:\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"doclen:  The document's length (unnormalised). You need to call\n"
		"need_stat(DOC_LENGTH) if you use this value.\n"
		"\n"
		"uniqterms:  Number of unique terms in the document. You need to call\n"
		"need_stat(UNIQUE_TERMS) if you use this value.\n"
		"\n"
		"wdfdocmax:  Maximum wdf value in the document. You need to call\n"
		"need_stat(WDF_DOC_MAX) if you use this value.\n"
		"\n"
		"The wdfdocmax parameter was added in Xapian 2.0.0. \n"
		""},
	 { "Weight_get_maxextra", _wrap_Weight_get_maxextra, METH_O, "\n"
		"\n"
		"\n"
		"Return an upper bound on what get_sumextra() can return for any\n"
		"document.\n"
		"\n"
		"virtual double Xapian::Weight::get_maxextra() const\n"
		"Xapian::Weight::get_maxextra The default implementation always returns\n"
		"0 (in Xapian < 2.0.0 this was a pure virtual method).\n"
		"\n"
		"This information is used by the matcher to perform various\n"
		"optimisations, so strive to make the bound as tight as possible. \n"
		""},
	 { "Weight_create", _wrap_Weight_create, METH_VARARGS, NULL},
	 { "Weight_create_from_parameters", _wrap_Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"virtual Weight * Xapian::Weight::create_from_parameters(const char\n"
		"*params) const Xapian::Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "Weight_swigregister", Weight_swigregister, METH_O, NULL},
	 { "new_BoolWeight", _wrap_new_BoolWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a BoolWeight.\n"
		"\n"
		"Xapian::BoolWeight::BoolWeight() Xapian::BoolWeight::BoolWeight\n"
		""},
	 { "BoolWeight_create_from_parameters", _wrap_BoolWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BoolWeight * Xapian::BoolWeight::create_from_parameters(const char\n"
		"*params) const Xapian::BoolWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BoolWeight", _wrap_delete_BoolWeight, METH_O, NULL},
	 { "BoolWeight_swigregister", BoolWeight_swigregister, METH_O, NULL},
	 { "BoolWeight_swiginit", BoolWeight_swiginit, METH_VARARGS, NULL},
	 { "new_TfIdfWeight", _wrap_new_TfIdfWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a TfIdfWeight using the default normalizations (\"ntn\").\n"
		"\n"
		"Xapian::TfIdfWeight::TfIdfWeight() Xapian::TfIdfWeight::TfIdfWeight\n"
		""},
	 { "TfIdfWeight_create_from_parameters", _wrap_TfIdfWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"TfIdfWeight * Xapian::TfIdfWeight::create_from_parameters(const char\n"
		"*params) const Xapian::TfIdfWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_TfIdfWeight", _wrap_delete_TfIdfWeight, METH_O, NULL},
	 { "TfIdfWeight_swigregister", TfIdfWeight_swigregister, METH_O, NULL},
	 { "TfIdfWeight_swiginit", TfIdfWeight_swiginit, METH_VARARGS, NULL},
	 { "new_BM25Weight", _wrap_new_BM25Weight, METH_VARARGS, "Xapian::BM25Weight::BM25Weight() Xapian::BM25Weight::BM25Weight"},
	 { "BM25Weight_create_from_parameters", _wrap_BM25Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BM25Weight * Xapian::BM25Weight::create_from_parameters(const char\n"
		"*params) const Xapian::BM25Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BM25Weight", _wrap_delete_BM25Weight, METH_O, NULL},
	 { "BM25Weight_swigregister", BM25Weight_swigregister, METH_O, NULL},
	 { "BM25Weight_swiginit", BM25Weight_swiginit, METH_VARARGS, NULL},
	 { "new_BM25PlusWeight", _wrap_new_BM25PlusWeight, METH_VARARGS, "\n"
		"Xapian::BM25PlusWeight::BM25PlusWeight()\n"
		"Xapian::BM25PlusWeight::BM25PlusWeight\n"
		""},
	 { "BM25PlusWeight_create_from_parameters", _wrap_BM25PlusWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BM25PlusWeight * Xapian::BM25PlusWeight::create_from_parameters(const\n"
		"char *params) const Xapian::BM25PlusWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BM25PlusWeight", _wrap_delete_BM25PlusWeight, METH_O, NULL},
	 { "BM25PlusWeight_swigregister", BM25PlusWeight_swigregister, METH_O, NULL},
	 { "BM25PlusWeight_swiginit", BM25PlusWeight_swiginit, METH_VARARGS, NULL},
	 { "new_TradWeight", _wrap_new_TradWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a TradWeight.\n"
		"\n"
		"Xapian::TradWeight::TradWeight(double k=1.0)\n"
		"Xapian::TradWeight::TradWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"k:  A non-negative parameter controlling how influential within-\n"
		"document- frequency (wdf) and document length are. k=0 means that wdf\n"
		"and document length don't affect the weights. The larger k is, the\n"
		"more they do. (default 1) \n"
		""},
	 { "delete_TradWeight", _wrap_delete_TradWeight, METH_O, NULL},
	 { "TradWeight_swigregister", TradWeight_swigregister, METH_O, NULL},
	 { "TradWeight_swiginit", TradWeight_swiginit, METH_VARARGS, NULL},
	 { "new_InL2Weight", _wrap_new_InL2Weight, METH_VARARGS, "Xapian::InL2Weight::InL2Weight() Xapian::InL2Weight::InL2Weight"},
	 { "InL2Weight_create_from_parameters", _wrap_InL2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"InL2Weight * Xapian::InL2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::InL2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_InL2Weight", _wrap_delete_InL2Weight, METH_O, NULL},
	 { "InL2Weight_swigregister", InL2Weight_swigregister, METH_O, NULL},
	 { "InL2Weight_swiginit", InL2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_IfB2Weight", _wrap_new_IfB2Weight, METH_VARARGS, "Xapian::IfB2Weight::IfB2Weight() Xapian::IfB2Weight::IfB2Weight"},
	 { "IfB2Weight_create_from_parameters", _wrap_IfB2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"IfB2Weight * Xapian::IfB2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::IfB2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_IfB2Weight", _wrap_delete_IfB2Weight, METH_O, NULL},
	 { "IfB2Weight_swigregister", IfB2Weight_swigregister, METH_O, NULL},
	 { "IfB2Weight_swiginit", IfB2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_IneB2Weight", _wrap_new_IneB2Weight, METH_VARARGS, "Xapian::IneB2Weight::IneB2Weight() Xapian::IneB2Weight::IneB2Weight"},
	 { "IneB2Weight_create_from_parameters", _wrap_IneB2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"IneB2Weight * Xapian::IneB2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::IneB2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_IneB2Weight", _wrap_delete_IneB2Weight, METH_O, NULL},
	 { "IneB2Weight_swigregister", IneB2Weight_swigregister, METH_O, NULL},
	 { "IneB2Weight_swiginit", IneB2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_BB2Weight", _wrap_new_BB2Weight, METH_VARARGS, "Xapian::BB2Weight::BB2Weight() Xapian::BB2Weight::BB2Weight"},
	 { "BB2Weight_create_from_parameters", _wrap_BB2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"BB2Weight * Xapian::BB2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::BB2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_BB2Weight", _wrap_delete_BB2Weight, METH_O, NULL},
	 { "BB2Weight_swigregister", BB2Weight_swigregister, METH_O, NULL},
	 { "BB2Weight_swiginit", BB2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_DLHWeight", _wrap_new_DLHWeight, METH_NOARGS, "Xapian::DLHWeight::DLHWeight() Xapian::DLHWeight::DLHWeight"},
	 { "DLHWeight_create_from_parameters", _wrap_DLHWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"DLHWeight * Xapian::DLHWeight::create_from_parameters(const char\n"
		"*params) const Xapian::DLHWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_DLHWeight", _wrap_delete_DLHWeight, METH_O, NULL},
	 { "DLHWeight_swigregister", DLHWeight_swigregister, METH_O, NULL},
	 { "DLHWeight_swiginit", DLHWeight_swiginit, METH_VARARGS, NULL},
	 { "new_PL2Weight", _wrap_new_PL2Weight, METH_VARARGS, "Xapian::PL2Weight::PL2Weight() Xapian::PL2Weight::PL2Weight"},
	 { "PL2Weight_create_from_parameters", _wrap_PL2Weight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"PL2Weight * Xapian::PL2Weight::create_from_parameters(const char\n"
		"*params) const Xapian::PL2Weight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_PL2Weight", _wrap_delete_PL2Weight, METH_O, NULL},
	 { "PL2Weight_swigregister", PL2Weight_swigregister, METH_O, NULL},
	 { "PL2Weight_swiginit", PL2Weight_swiginit, METH_VARARGS, NULL},
	 { "new_PL2PlusWeight", _wrap_new_PL2PlusWeight, METH_VARARGS, "\n"
		"Xapian::PL2PlusWeight::PL2PlusWeight()\n"
		"Xapian::PL2PlusWeight::PL2PlusWeight\n"
		""},
	 { "PL2PlusWeight_create_from_parameters", _wrap_PL2PlusWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"PL2PlusWeight * Xapian::PL2PlusWeight::create_from_parameters(const\n"
		"char *params) const Xapian::PL2PlusWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_PL2PlusWeight", _wrap_delete_PL2PlusWeight, METH_O, NULL},
	 { "PL2PlusWeight_swigregister", PL2PlusWeight_swigregister, METH_O, NULL},
	 { "PL2PlusWeight_swiginit", PL2PlusWeight_swiginit, METH_VARARGS, NULL},
	 { "new_DPHWeight", _wrap_new_DPHWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a DPHWeight.\n"
		"\n"
		"Xapian::DPHWeight::DPHWeight() Xapian::DPHWeight::DPHWeight\n"
		""},
	 { "DPHWeight_create_from_parameters", _wrap_DPHWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"DPHWeight * Xapian::DPHWeight::create_from_parameters(const char\n"
		"*params) const Xapian::DPHWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_DPHWeight", _wrap_delete_DPHWeight, METH_O, NULL},
	 { "DPHWeight_swigregister", DPHWeight_swigregister, METH_O, NULL},
	 { "DPHWeight_swiginit", DPHWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LMJMWeight", _wrap_new_LMJMWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LMJMWeight.\n"
		"\n"
		"Xapian::LMJMWeight::LMJMWeight(double lambda=0.0)\n"
		"Xapian::LMJMWeight::LMJMWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"lambda:  A parameter strictly between 0 and 1 which linearly\n"
		"interpolates between the maximum likelihood model (the limit as λ→0)\n"
		"and the collection model (the limit as λ→1).\n"
		"\n"
		"Values of λ around 0.1 are apparently optimal for short queries and\n"
		"around 0.7 for long queries. If lambda is out of range (i.e. <= 0 or\n"
		">= 1) then the λ value used is chosen dynamically based on the query\n"
		"length using the formula:\n"
		"\n"
		"(query_length - 1) / 10.0\n"
		"\n"
		"The result is clamped to 0.1 for query_length <= 2, and to 0.7 for\n"
		"query_length >= 8. \n"
		""},
	 { "LMJMWeight_create_from_parameters", _wrap_LMJMWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LMJMWeight * Xapian::LMJMWeight::create_from_parameters(const char\n"
		"*params) const Xapian::LMJMWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LMJMWeight", _wrap_delete_LMJMWeight, METH_O, NULL},
	 { "LMJMWeight_swigregister", LMJMWeight_swigregister, METH_O, NULL},
	 { "LMJMWeight_swiginit", LMJMWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LMDirichletWeight", _wrap_new_LMDirichletWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LMDirichletWeight.\n"
		"\n"
		"Xapian::LMDirichletWeight::LMDirichletWeight(double mu=2000.0, double\n"
		"delta=0.05) Xapian::LMDirichletWeight::LMDirichletWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"mu:  A parameter which is > 0. Default: 2000\n"
		"\n"
		"delta:  A parameter which is >= 0, which is \"a pseudo [wdf] value to\n"
		"control the scale of the [wdf] lower bound\". If this parameter is >\n"
		"0, then the smoothing is Dir+; if it's zero, it's Dirichlet. Default:\n"
		"0.05 \n"
		""},
	 { "LMDirichletWeight_create_from_parameters", _wrap_LMDirichletWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LMDirichletWeight *\n"
		"Xapian::LMDirichletWeight::create_from_parameters(const char *params)\n"
		"const Xapian::LMDirichletWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LMDirichletWeight", _wrap_delete_LMDirichletWeight, METH_O, NULL},
	 { "LMDirichletWeight_swigregister", LMDirichletWeight_swigregister, METH_O, NULL},
	 { "LMDirichletWeight_swiginit", LMDirichletWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LMAbsDiscountWeight", _wrap_new_LMAbsDiscountWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LMAbsDiscountWeight.\n"
		"\n"
		"Xapian::LMAbsDiscountWeight::LMAbsDiscountWeight(double delta=0.7)\n"
		"Xapian::LMAbsDiscountWeight::LMAbsDiscountWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"delta:  A parameter between 0 and 1. Default: 0.7 \n"
		""},
	 { "LMAbsDiscountWeight_create_from_parameters", _wrap_LMAbsDiscountWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LMAbsDiscountWeight *\n"
		"Xapian::LMAbsDiscountWeight::create_from_parameters(const char\n"
		"*params) const Xapian::LMAbsDiscountWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LMAbsDiscountWeight", _wrap_delete_LMAbsDiscountWeight, METH_O, NULL},
	 { "LMAbsDiscountWeight_swigregister", LMAbsDiscountWeight_swigregister, METH_O, NULL},
	 { "LMAbsDiscountWeight_swiginit", LMAbsDiscountWeight_swiginit, METH_VARARGS, NULL},
	 { "new_LM2StageWeight", _wrap_new_LM2StageWeight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LM2StageWeight.\n"
		"\n"
		"Xapian::LM2StageWeight::LM2StageWeight(double lambda=0.7, double\n"
		"mu=2000.0) Xapian::LM2StageWeight::LM2StageWeight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"lambda:  A parameter between 0 and 1 which linearly interpolates\n"
		"between the maximum likelihood model (at 0) and the collection model\n"
		"(at 1). Default: 0.7\n"
		"\n"
		"mu:  A parameter which is greater than 0. Default: 2000 \n"
		""},
	 { "LM2StageWeight_create_from_parameters", _wrap_LM2StageWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"LM2StageWeight * Xapian::LM2StageWeight::create_from_parameters(const\n"
		"char *params) const Xapian::LM2StageWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_LM2StageWeight", _wrap_delete_LM2StageWeight, METH_O, NULL},
	 { "LM2StageWeight_swigregister", LM2StageWeight_swigregister, METH_O, NULL},
	 { "LM2StageWeight_swiginit", LM2StageWeight_swiginit, METH_VARARGS, NULL},
	 { "CoordWeight_init", _wrap_CoordWeight_init, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Allow the subclass to perform any initialisation it needs to.\n"
		"\n"
		"void Xapian::CoordWeight::init(double factor_)\n"
		"Xapian::CoordWeight::init\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"factor:  Any scaling factor (e.g. from OP_SCALE_WEIGHT). If the Weight\n"
		"object is for the term-independent weight supplied by\n"
		"get_sumextra()/get_maxextra(), then init(0.0) is called (starting from\n"
		"Xapian 1.2.11 and 1.3.1 - earlier versions failed to call init() for\n"
		"such Weight objects). \n"
		""},
	 { "new_CoordWeight", _wrap_new_CoordWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a CoordWeight.\n"
		"\n"
		"Xapian::CoordWeight::CoordWeight() Xapian::CoordWeight::CoordWeight\n"
		""},
	 { "CoordWeight_create_from_parameters", _wrap_CoordWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"CoordWeight * Xapian::CoordWeight::create_from_parameters(const char\n"
		"*params) const Xapian::CoordWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_CoordWeight", _wrap_delete_CoordWeight, METH_O, NULL},
	 { "CoordWeight_swigregister", CoordWeight_swigregister, METH_O, NULL},
	 { "CoordWeight_swiginit", CoordWeight_swiginit, METH_VARARGS, NULL},
	 { "new_DiceWeight", _wrap_new_DiceWeight, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Construct a DiceWeight.\n"
		"\n"
		"Xapian::DiceWeight::DiceWeight() Xapian::DiceWeight::DiceWeight\n"
		""},
	 { "DiceWeight_create_from_parameters", _wrap_DiceWeight_create_from_parameters, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Create from a human-readable parameter string.\n"
		"\n"
		"DiceWeight * Xapian::DiceWeight::create_from_parameters(const char\n"
		"*params) const Xapian::DiceWeight::create_from_parameters\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"params:  string containing weighting scheme parameter values.\n"
		"\n"
		"2.0.0 \n"
		""},
	 { "delete_DiceWeight", _wrap_delete_DiceWeight, METH_O, NULL},
	 { "DiceWeight_swigregister", DiceWeight_swigregister, METH_O, NULL},
	 { "DiceWeight_swiginit", DiceWeight_swiginit, METH_VARARGS, NULL},
	 { "new_Compactor", _wrap_new_Compactor, METH_O, "Xapian::Compactor::Compactor() Xapian::Compactor::Compactor"},
	 { "delete_Compactor", _wrap_delete_Compactor, METH_O, "\n"
		"virtual\n"
		"Xapian::Compactor::~Compactor() Xapian::Compactor::~Compactor\n"
		""},
	 { "Compactor_set_status", _wrap_Compactor_set_status, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Update progress.\n"
		"\n"
		"virtual void Xapian::Compactor::set_status(const std::string &table,\n"
		"const std::string &status) Xapian::Compactor::set_status Subclass this\n"
		"method if you want to get progress updates during compaction. This is\n"
		"called for each table first with empty status, And then one or more\n"
		"times with non-empty status.\n"
		"\n"
		"The default implementation does nothing.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"table:  The table currently being compacted.\n"
		"\n"
		"status:  A status message. \n"
		""},
	 { "Compactor_resolve_duplicate_metadata", _wrap_Compactor_resolve_duplicate_metadata, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Resolve multiple user metadata entries with the same key.\n"
		"\n"
		"virtual std::string\n"
		"Xapian::Compactor::resolve_duplicate_metadata(const std::string &key,\n"
		"size_t num_tags, const std::string tags[])\n"
		"Xapian::Compactor::resolve_duplicate_metadata When merging, if the\n"
		"same user metadata key is set in more than one input, then this method\n"
		"is called to allow this to be resolving in an appropriate way.\n"
		"\n"
		"The default implementation just returns tags[0].\n"
		"\n"
		"For multipass this will currently get called multiple times for the\n"
		"same key if there are duplicates to resolve in each pass, but this may\n"
		"change in the future.\n"
		"\n"
		"Since 1.4.6, an implementation of this method can return an empty\n"
		"string to indicate that the appropriate result is to not set a value\n"
		"for this user metadata key in the output database. In older versions,\n"
		"you should not return an empty string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The metadata key with duplicate entries.\n"
		"\n"
		"num_tags:  How many tags there are.\n"
		"\n"
		"tags:  An array of num_tags strings containing the tags to merge. \n"
		""},
	 { "disown_Compactor", _wrap_disown_Compactor, METH_O, NULL},
	 { "Compactor_swigregister", Compactor_swigregister, METH_O, NULL},
	 { "Compactor_swiginit", Compactor_swiginit, METH_VARARGS, NULL},
	 { "new_PostingSource", _wrap_new_PostingSource, METH_O, "\n"
		"\n"
		"\n"
		"Allow subclasses to be instantiated.\n"
		"\n"
		"Xapian::PostingSource::PostingSource() noexcept\n"
		"Xapian::PostingSource::PostingSource\n"
		""},
	 { "delete_PostingSource", _wrap_delete_PostingSource, METH_O, "\n"
		"virtual\n"
		"Xapian::PostingSource::~PostingSource()\n"
		"Xapian::PostingSource::~PostingSource\n"
		""},
	 { "PostingSource_get_termfreq_min", _wrap_PostingSource_get_termfreq_min, METH_O, "\n"
		"\n"
		"\n"
		"A lower bound on the number of documents this object can return.\n"
		"\n"
		"virtual Xapian::doccount Xapian::PostingSource::get_termfreq_min()\n"
		"const =0 Xapian::PostingSource::get_termfreq_min  Xapian will always\n"
		"call reset() on a PostingSource before calling this for the first\n"
		"time. \n"
		""},
	 { "PostingSource_get_termfreq_est", _wrap_PostingSource_get_termfreq_est, METH_O, "\n"
		"\n"
		"\n"
		"An estimate of the number of documents this object can return.\n"
		"\n"
		"virtual Xapian::doccount Xapian::PostingSource::get_termfreq_est()\n"
		"const =0 Xapian::PostingSource::get_termfreq_est It must always be\n"
		"true that:\n"
		"\n"
		"get_termfreq_min() <= get_termfreq_est() <= get_termfreq_max()\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time. \n"
		""},
	 { "PostingSource_get_termfreq_max", _wrap_PostingSource_get_termfreq_max, METH_O, "\n"
		"\n"
		"\n"
		"An upper bound on the number of documents this object can return.\n"
		"\n"
		"virtual Xapian::doccount Xapian::PostingSource::get_termfreq_max()\n"
		"const =0 Xapian::PostingSource::get_termfreq_max  Xapian will always\n"
		"call reset() on a PostingSource before calling this for the first\n"
		"time. \n"
		""},
	 { "PostingSource_set_maxweight", _wrap_PostingSource_set_maxweight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Specify an upper bound on what get_weight() will return from now on.\n"
		"\n"
		"void Xapian::PostingSource::set_maxweight(double max_weight)\n"
		"Xapian::PostingSource::set_maxweight This upper bound is used by the\n"
		"matcher to perform various optimisations, so if you can return a good\n"
		"bound, then matches will generally run faster.\n"
		"\n"
		"This method should be called after calling reset(), and may be called\n"
		"during iteration if the upper bound drops. It is probably only useful\n"
		"to call from subclasses (it was actually a \"protected\" method prior\n"
		"to Xapian 1.3.4, but that makes it tricky to wrap for other\n"
		"languages).\n"
		"\n"
		"It is valid for the posting source to have returned a higher value\n"
		"from get_weight() earlier in the iteration, but the posting source\n"
		"must not return a higher value from get_weight() than the currently\n"
		"set upper bound, and the upper bound must not be increased (until\n"
		"reset() has been called).\n"
		"\n"
		"If you don't call this method, the upper bound will default to 0, for\n"
		"convenience when implementing \"weight-less\" PostingSource\n"
		"subclasses.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"max_weight:  The upper bound to set. \n"
		""},
	 { "PostingSource_get_maxweight", _wrap_PostingSource_get_maxweight, METH_O, "\n"
		"\n"
		"\n"
		"Return the currently set upper bound on what get_weight() can return.\n"
		"\n"
		"double Xapian::PostingSource::get_maxweight() const noexcept\n"
		"Xapian::PostingSource::get_maxweight\n"
		""},
	 { "PostingSource_get_weight", _wrap_PostingSource_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Return the weight contribution for the current document.\n"
		"\n"
		"virtual double Xapian::PostingSource::get_weight() const\n"
		"Xapian::PostingSource::get_weight This default implementation always\n"
		"returns 0, for convenience when implementing \"weight-less\"\n"
		"PostingSource subclasses.\n"
		"\n"
		"This method may assume that it will only be called when there is a\n"
		"\"current document\". In detail: Xapian will always call reset() on a\n"
		"PostingSource before calling this for the first time. It will also\n"
		"only call this if the PostingSource reports that it is pointing to a\n"
		"valid document (ie, it will not call it before calling at least one of\n"
		"next(), skip_to() or check(), and will ensure that the PostingSource\n"
		"is not at the end by calling at_end()). \n"
		""},
	 { "PostingSource_get_docid", _wrap_PostingSource_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Return the current docid.\n"
		"\n"
		"virtual Xapian::docid Xapian::PostingSource::get_docid() const =0\n"
		"Xapian::PostingSource::get_docid This method may assume that it will\n"
		"only be called when there is a \"current document\". See  get_weight()\n"
		"for details.\n"
		"\n"
		"Note: in the case of a multi-database search, the returned docid\n"
		"should be in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details. \n"
		""},
	 { "PostingSource___next__", _wrap_PostingSource___next__, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the current position to the next matching document.\n"
		"\n"
		"virtual void Xapian::PostingSource::next(double min_wt)=0\n"
		"Xapian::PostingSource::next The PostingSource starts before the first\n"
		"entry in the list, so next(), skip_to() or check() must be called\n"
		"before any methods which need the context of the current position.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "PostingSource_skip_to", _wrap_PostingSource_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance to the specified docid.\n"
		"\n"
		"virtual void Xapian::PostingSource::skip_to(Xapian::docid did, double\n"
		"min_wt) Xapian::PostingSource::skip_to If the specified docid isn't in\n"
		"the list, position ourselves on the first document after it (or\n"
		"at_end() if no greater docids are present).\n"
		"\n"
		"If the current position is already the specified docid, this method\n"
		"will leave the position unmodified.\n"
		"\n"
		"If the specified docid is earlier than the current position, the\n"
		"behaviour is unspecified. A sensible behaviour would be to leave the\n"
		"current position unmodified, but it is also reasonable to move to the\n"
		"specified docid.\n"
		"\n"
		"The default implementation calls next() repeatedly, which works but\n"
		"skip_to() can often be implemented much more efficiently.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to advance to.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "PostingSource_check", _wrap_PostingSource_check, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if the specified docid occurs.\n"
		"\n"
		"virtual bool Xapian::PostingSource::check(Xapian::docid did, double\n"
		"min_wt) Xapian::PostingSource::check The caller is required to ensure\n"
		"that the specified document id did actually exists in the database. If\n"
		"it does, it must move to that document id, and return true. If it does\n"
		"not, it may either:\n"
		"\n"
		"return true, having moved to a definite position (including\n"
		"\"at_end\"), which must be the same position as skip_to() would have\n"
		"moved to.\n"
		"\n"
		"or\n"
		"\n"
		"return false, having moved to an \"indeterminate\" position, such that\n"
		"a subsequent call to next() or skip_to() will move to the next\n"
		"matching position after did.\n"
		"\n"
		"Generally, this method should act like skip_to() and return true if\n"
		"that can be done at little extra cost.\n"
		"\n"
		"Otherwise it should simply check if a particular docid is present,\n"
		"returning true if it is, and false if it isn't.\n"
		"\n"
		"The default implementation calls skip_to() and always returns true.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to check.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "PostingSource_at_end", _wrap_PostingSource_at_end, METH_O, "\n"
		"\n"
		"\n"
		"Return true if the current position is past the last entry in this\n"
		"list.\n"
		"\n"
		"virtual bool Xapian::PostingSource::at_end() const =0\n"
		"Xapian::PostingSource::at_end At least one of  next(),  skip_to() or\n"
		"check() will be called before this method is first called. \n"
		""},
	 { "PostingSource_name", _wrap_PostingSource_name, METH_O, "\n"
		"\n"
		"\n"
		"Name of the posting source class.\n"
		"\n"
		"virtual std::string Xapian::PostingSource::name() const\n"
		"Xapian::PostingSource::name This is used when serialising and\n"
		"unserialising posting sources; for example, for performing remote\n"
		"searches.\n"
		"\n"
		"If the subclass is in a C++ namespace, the namespace should be\n"
		"included in the name, using \"::\" as a separator. For example, for a\n"
		"PostingSource subclass called \"FooPostingSource\" in the \"Xapian\"\n"
		"namespace the result of this call should be\n"
		"\"Xapian::FooPostingSource\".\n"
		"\n"
		"This should only be implemented if serialise() and unserialise() are\n"
		"also implemented. The default implementation returns an empty string.\n"
		"\n"
		"If this returns an empty string, Xapian will assume that serialise()\n"
		"and unserialise() are not implemented. \n"
		""},
	 { "PostingSource_reset", _wrap_PostingSource_reset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set this PostingSource to the start of the list of postings.\n"
		"\n"
		"virtual void Xapian::PostingSource::reset(const Database &db,\n"
		"Xapian::doccount shard_index) Xapian::PostingSource::reset This is\n"
		"called automatically by the matcher prior to each query being\n"
		"processed.\n"
		"\n"
		"If a PostingSource is used for multiple searches,  reset() will\n"
		"therefore be called multiple times, and must handle this by using the\n"
		"database passed in the most recent call.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database which the PostingSource should iterate through.\n"
		"\n"
		"shard_index:  The 0-based index indicating which shard in a multi-\n"
		"database db is. This can be useful if you have an external source of\n"
		"postings corresponding to each shard.\n"
		"\n"
		"Note: in the case of a multi-database search, a separate PostingSource\n"
		"will be used for each database (the separate PostingSources will be\n"
		"obtained using  clone()), and each PostingSource will be passed one of\n"
		"the sub-databases as the db parameter here. The db parameter will\n"
		"therefore always refer to a single database. All docids passed to, or\n"
		"returned from, the PostingSource refer to docids in that single\n"
		"database, rather than in the multi- database.\n"
		"\n"
		"A default implementation is provided which calls the older init()\n"
		"method to allow existing subclasses to continue to work, but the\n"
		"default implementation of init() throws Xapian::InvalidOperationError\n"
		"so you must override either this method or init(). In new code,\n"
		"override this method in preference.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "PostingSource_init", _wrap_PostingSource_init, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Older method which did the same job as reset().\n"
		"\n"
		"virtual void Xapian::PostingSource::init(const Database &db)\n"
		"Xapian::PostingSource::init Prior to 2.0.0, instead of reset() there\n"
		"was a method called init() taking one parameter. The default\n"
		"implementation of reset() calls init() to allow existing subclasses to\n"
		"continue to work.\n"
		"\n"
		"A default implementation of init() is provided so that new subclasses\n"
		"can just override reset() (the default implementation should not\n"
		"actually get called, and will throw Xapian::InvalidOperationError if\n"
		"it is). \n"
		""},
	 { "PostingSource___str__", _wrap_PostingSource___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::PostingSource::get_description() const\n"
		"Xapian::PostingSource::get_description This default implementation\n"
		"returns a generic answer. This default it provided to avoid forcing\n"
		"those deriving their own PostingSource subclass from having to\n"
		"implement this (they may not care what get_description() gives for\n"
		"their subclass). \n"
		""},
	 { "PostingSource_release", _wrap_PostingSource_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const PostingSource * Xapian::PostingSource::release() const\n"
		"Xapian::PostingSource::release You can transfer ownership of a\n"
		"dynamically allocated PostingSource object to Xapian by calling\n"
		"release() and then passing the object to a Xapian method. Xapian will\n"
		"arrange to delete the object once it is no longer required. \n"
		""},
	 { "disown_PostingSource", _wrap_disown_PostingSource, METH_O, NULL},
	 { "PostingSource_swigregister", PostingSource_swigregister, METH_O, NULL},
	 { "PostingSource_swiginit", PostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_ValuePostingSource", _wrap_new_ValuePostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a ValuePostingSource.\n"
		"\n"
		"Xapian::ValuePostingSource::ValuePostingSource(Xapian::valueno slot_)\n"
		"noexcept Xapian::ValuePostingSource::ValuePostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from. \n"
		""},
	 { "ValuePostingSource_get_termfreq_min", _wrap_ValuePostingSource_get_termfreq_min, METH_O, "\n"
		"\n"
		"\n"
		"A lower bound on the number of documents this object can return.\n"
		"\n"
		"Xapian::doccount Xapian::ValuePostingSource::get_termfreq_min() const\n"
		"Xapian::ValuePostingSource::get_termfreq_min  Xapian will always call\n"
		"reset() on a PostingSource before calling this for the first time. \n"
		""},
	 { "ValuePostingSource_get_termfreq_est", _wrap_ValuePostingSource_get_termfreq_est, METH_O, "\n"
		"\n"
		"\n"
		"An estimate of the number of documents this object can return.\n"
		"\n"
		"Xapian::doccount Xapian::ValuePostingSource::get_termfreq_est() const\n"
		"Xapian::ValuePostingSource::get_termfreq_est It must always be true\n"
		"that:\n"
		"\n"
		"get_termfreq_min() <= get_termfreq_est() <= get_termfreq_max()\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time. \n"
		""},
	 { "ValuePostingSource_get_termfreq_max", _wrap_ValuePostingSource_get_termfreq_max, METH_O, "\n"
		"\n"
		"\n"
		"An upper bound on the number of documents this object can return.\n"
		"\n"
		"Xapian::doccount Xapian::ValuePostingSource::get_termfreq_max() const\n"
		"Xapian::ValuePostingSource::get_termfreq_max  Xapian will always call\n"
		"reset() on a PostingSource before calling this for the first time. \n"
		""},
	 { "ValuePostingSource___next__", _wrap_ValuePostingSource___next__, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance the current position to the next matching document.\n"
		"\n"
		"void Xapian::ValuePostingSource::next(double min_wt)\n"
		"Xapian::ValuePostingSource::next The PostingSource starts before the\n"
		"first entry in the list, so next(), skip_to() or check() must be\n"
		"called before any methods which need the context of the current\n"
		"position.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "ValuePostingSource_skip_to", _wrap_ValuePostingSource_skip_to, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Advance to the specified docid.\n"
		"\n"
		"void Xapian::ValuePostingSource::skip_to(Xapian::docid min_docid,\n"
		"double min_wt) Xapian::ValuePostingSource::skip_to If the specified\n"
		"docid isn't in the list, position ourselves on the first document\n"
		"after it (or at_end() if no greater docids are present).\n"
		"\n"
		"If the current position is already the specified docid, this method\n"
		"will leave the position unmodified.\n"
		"\n"
		"If the specified docid is earlier than the current position, the\n"
		"behaviour is unspecified. A sensible behaviour would be to leave the\n"
		"current position unmodified, but it is also reasonable to move to the\n"
		"specified docid.\n"
		"\n"
		"The default implementation calls next() repeatedly, which works but\n"
		"skip_to() can often be implemented much more efficiently.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to advance to.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "ValuePostingSource_check", _wrap_ValuePostingSource_check, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Check if the specified docid occurs.\n"
		"\n"
		"bool Xapian::ValuePostingSource::check(Xapian::docid min_docid, double\n"
		"min_wt) Xapian::ValuePostingSource::check The caller is required to\n"
		"ensure that the specified document id did actually exists in the\n"
		"database. If it does, it must move to that document id, and return\n"
		"true. If it does not, it may either:\n"
		"\n"
		"return true, having moved to a definite position (including\n"
		"\"at_end\"), which must be the same position as skip_to() would have\n"
		"moved to.\n"
		"\n"
		"or\n"
		"\n"
		"return false, having moved to an \"indeterminate\" position, such that\n"
		"a subsequent call to next() or skip_to() will move to the next\n"
		"matching position after did.\n"
		"\n"
		"Generally, this method should act like skip_to() and return true if\n"
		"that can be done at little extra cost.\n"
		"\n"
		"Otherwise it should simply check if a particular docid is present,\n"
		"returning true if it is, and false if it isn't.\n"
		"\n"
		"The default implementation calls skip_to() and always returns true.\n"
		"\n"
		"Xapian will always call reset() on a PostingSource before calling this\n"
		"for the first time.\n"
		"\n"
		"Note: in the case of a multi-database search, the docid specified is\n"
		"the docid in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to check.\n"
		"\n"
		"min_wt:  The minimum weight contribution that is needed (this is just\n"
		"a hint which subclasses may ignore). \n"
		""},
	 { "ValuePostingSource_at_end", _wrap_ValuePostingSource_at_end, METH_O, "\n"
		"\n"
		"\n"
		"Return true if the current position is past the last entry in this\n"
		"list.\n"
		"\n"
		"bool Xapian::ValuePostingSource::at_end() const\n"
		"Xapian::ValuePostingSource::at_end At least one of  next(),  skip_to()\n"
		"or  check() will be called before this method is first called. \n"
		""},
	 { "ValuePostingSource_get_docid", _wrap_ValuePostingSource_get_docid, METH_O, "\n"
		"\n"
		"\n"
		"Return the current docid.\n"
		"\n"
		"Xapian::docid Xapian::ValuePostingSource::get_docid() const\n"
		"Xapian::ValuePostingSource::get_docid This method may assume that it\n"
		"will only be called when there is a \"current document\". See\n"
		"get_weight() for details.\n"
		"\n"
		"Note: in the case of a multi-database search, the returned docid\n"
		"should be in the single subdatabase relevant to this posting source.\n"
		"See the  reset() method for details. \n"
		""},
	 { "ValuePostingSource_reset", _wrap_ValuePostingSource_reset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set this PostingSource to the start of the list of postings.\n"
		"\n"
		"void Xapian::ValuePostingSource::reset(const Database &db_,\n"
		"Xapian::doccount shard_index) Xapian::ValuePostingSource::reset This\n"
		"is called automatically by the matcher prior to each query being\n"
		"processed.\n"
		"\n"
		"If a PostingSource is used for multiple searches,  reset() will\n"
		"therefore be called multiple times, and must handle this by using the\n"
		"database passed in the most recent call.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database which the PostingSource should iterate through.\n"
		"\n"
		"shard_index:  The 0-based index indicating which shard in a multi-\n"
		"database db is. This can be useful if you have an external source of\n"
		"postings corresponding to each shard.\n"
		"\n"
		"Note: in the case of a multi-database search, a separate PostingSource\n"
		"will be used for each database (the separate PostingSources will be\n"
		"obtained using  clone()), and each PostingSource will be passed one of\n"
		"the sub-databases as the db parameter here. The db parameter will\n"
		"therefore always refer to a single database. All docids passed to, or\n"
		"returned from, the PostingSource refer to docids in that single\n"
		"database, rather than in the multi- database.\n"
		"\n"
		"A default implementation is provided which calls the older init()\n"
		"method to allow existing subclasses to continue to work, but the\n"
		"default implementation of init() throws Xapian::InvalidOperationError\n"
		"so you must override either this method or init(). In new code,\n"
		"override this method in preference.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "ValuePostingSource_get_database", _wrap_ValuePostingSource_get_database, METH_O, "\n"
		"\n"
		"\n"
		"The database we're reading values from.\n"
		"\n"
		"Xapian::Database Xapian::ValuePostingSource::get_database() const\n"
		"Xapian::ValuePostingSource::get_database\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_get_slot", _wrap_ValuePostingSource_get_slot, METH_O, "\n"
		"\n"
		"\n"
		"The slot we're reading values from.\n"
		"\n"
		"Xapian::valueno Xapian::ValuePostingSource::get_slot() const\n"
		"Xapian::ValuePostingSource::get_slot\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_get_value", _wrap_ValuePostingSource_get_value, METH_O, "\n"
		"\n"
		"\n"
		"Read current value.\n"
		"\n"
		"std::string Xapian::ValuePostingSource::get_value() const\n"
		"Xapian::ValuePostingSource::get_value\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_done", _wrap_ValuePostingSource_done, METH_O, "\n"
		"\n"
		"\n"
		"End the iteration.\n"
		"\n"
		"void Xapian::ValuePostingSource::done()\n"
		"Xapian::ValuePostingSource::done Calls to at_end() will return true\n"
		"after calling this method.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_get_started", _wrap_ValuePostingSource_get_started, METH_O, "\n"
		"\n"
		"\n"
		"Flag indicating if we've started (true if we have).\n"
		"\n"
		"bool Xapian::ValuePostingSource::get_started() const\n"
		"Xapian::ValuePostingSource::get_started\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_set_termfreq_min", _wrap_ValuePostingSource_set_termfreq_min, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set a lower bound on the term frequency.\n"
		"\n"
		"void Xapian::ValuePostingSource::set_termfreq_min(Xapian::doccount\n"
		"termfreq_min_) Xapian::ValuePostingSource::set_termfreq_min Subclasses\n"
		"should set this if they are overriding the next(), skip_to() or\n"
		"check() methods to return fewer documents.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_set_termfreq_est", _wrap_ValuePostingSource_set_termfreq_est, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An estimate of the term frequency.\n"
		"\n"
		"void Xapian::ValuePostingSource::set_termfreq_est(Xapian::doccount\n"
		"termfreq_est_) Xapian::ValuePostingSource::set_termfreq_est Subclasses\n"
		"should set this if they are overriding the next(), skip_to() or\n"
		"check() methods.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource_set_termfreq_max", _wrap_ValuePostingSource_set_termfreq_max, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An upper bound on the term frequency.\n"
		"\n"
		"void Xapian::ValuePostingSource::set_termfreq_max(Xapian::doccount\n"
		"termfreq_max_) Xapian::ValuePostingSource::set_termfreq_max Subclasses\n"
		"should set this if they are overriding the next(), skip_to() or\n"
		"check() methods.\n"
		"\n"
		"Added in 1.2.23 and 1.3.5. \n"
		""},
	 { "ValuePostingSource___str__", _wrap_ValuePostingSource___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ValuePostingSource::get_description() const\n"
		"Xapian::ValuePostingSource::get_description This default\n"
		"implementation returns a generic answer. This default it provided to\n"
		"avoid forcing those deriving their own PostingSource subclass from\n"
		"having to implement this (they may not care what get_description()\n"
		"gives for their subclass). \n"
		""},
	 { "delete_ValuePostingSource", _wrap_delete_ValuePostingSource, METH_O, NULL},
	 { "disown_ValuePostingSource", _wrap_disown_ValuePostingSource, METH_O, NULL},
	 { "ValuePostingSource_swigregister", ValuePostingSource_swigregister, METH_O, NULL},
	 { "ValuePostingSource_swiginit", ValuePostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_ValueWeightPostingSource", _wrap_new_ValueWeightPostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a ValueWeightPostingSource.\n"
		"\n"
		"Xapian::ValueWeightPostingSource::ValueWeightPostingSource(Xapian::valueno\n"
		"slot_) Xapian::ValueWeightPostingSource::ValueWeightPostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from. \n"
		""},
	 { "ValueWeightPostingSource_get_weight", _wrap_ValueWeightPostingSource_get_weight, METH_O, "\n"
		"\n"
		"\n"
		"Return the weight contribution for the current document.\n"
		"\n"
		"double Xapian::ValueWeightPostingSource::get_weight() const\n"
		"Xapian::ValueWeightPostingSource::get_weight This default\n"
		"implementation always returns 0, for convenience when implementing\n"
		"\"weight-less\" PostingSource subclasses.\n"
		"\n"
		"This method may assume that it will only be called when there is a\n"
		"\"current document\". In detail: Xapian will always call reset() on a\n"
		"PostingSource before calling this for the first time. It will also\n"
		"only call this if the PostingSource reports that it is pointing to a\n"
		"valid document (ie, it will not call it before calling at least one of\n"
		"next(), skip_to() or check(), and will ensure that the PostingSource\n"
		"is not at the end by calling at_end()). \n"
		""},
	 { "ValueWeightPostingSource_name", _wrap_ValueWeightPostingSource_name, METH_O, "\n"
		"\n"
		"\n"
		"Name of the posting source class.\n"
		"\n"
		"std::string Xapian::ValueWeightPostingSource::name() const\n"
		"Xapian::ValueWeightPostingSource::name This is used when serialising\n"
		"and unserialising posting sources; for example, for performing remote\n"
		"searches.\n"
		"\n"
		"If the subclass is in a C++ namespace, the namespace should be\n"
		"included in the name, using \"::\" as a separator. For example, for a\n"
		"PostingSource subclass called \"FooPostingSource\" in the \"Xapian\"\n"
		"namespace the result of this call should be\n"
		"\"Xapian::FooPostingSource\".\n"
		"\n"
		"This should only be implemented if serialise() and unserialise() are\n"
		"also implemented. The default implementation returns an empty string.\n"
		"\n"
		"If this returns an empty string, Xapian will assume that serialise()\n"
		"and unserialise() are not implemented. \n"
		""},
	 { "ValueWeightPostingSource_reset", _wrap_ValueWeightPostingSource_reset, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set this PostingSource to the start of the list of postings.\n"
		"\n"
		"void Xapian::ValueWeightPostingSource::reset(const Database &db_,\n"
		"Xapian::doccount shard_index) Xapian::ValueWeightPostingSource::reset\n"
		"This is called automatically by the matcher prior to each query being\n"
		"processed.\n"
		"\n"
		"If a PostingSource is used for multiple searches,  reset() will\n"
		"therefore be called multiple times, and must handle this by using the\n"
		"database passed in the most recent call.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"db:  The database which the PostingSource should iterate through.\n"
		"\n"
		"shard_index:  The 0-based index indicating which shard in a multi-\n"
		"database db is. This can be useful if you have an external source of\n"
		"postings corresponding to each shard.\n"
		"\n"
		"Note: in the case of a multi-database search, a separate PostingSource\n"
		"will be used for each database (the separate PostingSources will be\n"
		"obtained using  clone()), and each PostingSource will be passed one of\n"
		"the sub-databases as the db parameter here. The db parameter will\n"
		"therefore always refer to a single database. All docids passed to, or\n"
		"returned from, the PostingSource refer to docids in that single\n"
		"database, rather than in the multi- database.\n"
		"\n"
		"A default implementation is provided which calls the older init()\n"
		"method to allow existing subclasses to continue to work, but the\n"
		"default implementation of init() throws Xapian::InvalidOperationError\n"
		"so you must override either this method or init(). In new code,\n"
		"override this method in preference.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "ValueWeightPostingSource___str__", _wrap_ValueWeightPostingSource___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::ValueWeightPostingSource::get_description() const\n"
		"Xapian::ValueWeightPostingSource::get_description This default\n"
		"implementation returns a generic answer. This default it provided to\n"
		"avoid forcing those deriving their own PostingSource subclass from\n"
		"having to implement this (they may not care what get_description()\n"
		"gives for their subclass). \n"
		""},
	 { "delete_ValueWeightPostingSource", _wrap_delete_ValueWeightPostingSource, METH_O, NULL},
	 { "disown_ValueWeightPostingSource", _wrap_disown_ValueWeightPostingSource, METH_O, NULL},
	 { "ValueWeightPostingSource_swigregister", ValueWeightPostingSource_swigregister, METH_O, NULL},
	 { "ValueWeightPostingSource_swiginit", ValueWeightPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_DecreasingValueWeightPostingSource", _wrap_new_DecreasingValueWeightPostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a DecreasingValueWeightPostingSource.\n"
		"\n"
		"Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPostingSource(Xapian::valueno\n"
		"slot_, Xapian::docid range_start_=0, Xapian::docid range_end_=0)\n"
		"Xapian::DecreasingValueWeightPostingSource::DecreasingValueWeightPosti\n"
		"ngSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from.\n"
		"\n"
		"range_start_:  Start of range of docids for which weights are known to\n"
		"be decreasing (default: first docid)\n"
		"\n"
		"range_end_:  End of range of docids for which weights are known to be\n"
		"decreasing (default: last docid) \n"
		""},
	 { "delete_DecreasingValueWeightPostingSource", _wrap_delete_DecreasingValueWeightPostingSource, METH_O, NULL},
	 { "DecreasingValueWeightPostingSource_swigregister", DecreasingValueWeightPostingSource_swigregister, METH_O, NULL},
	 { "DecreasingValueWeightPostingSource_swiginit", DecreasingValueWeightPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_ValueMapPostingSource", _wrap_new_ValueMapPostingSource, METH_O, "\n"
		"\n"
		"\n"
		"Construct a ValueMapPostingSource.\n"
		"\n"
		"Xapian::ValueMapPostingSource::ValueMapPostingSource(Xapian::valueno\n"
		"slot_) Xapian::ValueMapPostingSource::ValueMapPostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from. \n"
		""},
	 { "ValueMapPostingSource_add_mapping", _wrap_ValueMapPostingSource_add_mapping, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a mapping.\n"
		"\n"
		"void Xapian::ValueMapPostingSource::add_mapping(const std::string\n"
		"&key, double wt) Xapian::ValueMapPostingSource::add_mapping\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The key looked up from the value slot.\n"
		"\n"
		"wt:  The weight to give this key. \n"
		""},
	 { "ValueMapPostingSource_clear_mappings", _wrap_ValueMapPostingSource_clear_mappings, METH_O, "\n"
		"\n"
		"\n"
		"Clear all mappings.\n"
		"\n"
		"void Xapian::ValueMapPostingSource::clear_mappings()\n"
		"Xapian::ValueMapPostingSource::clear_mappings\n"
		""},
	 { "ValueMapPostingSource_set_default_weight", _wrap_ValueMapPostingSource_set_default_weight, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set a default weight for document values not in the map.\n"
		"\n"
		"void Xapian::ValueMapPostingSource::set_default_weight(double wt)\n"
		"Xapian::ValueMapPostingSource::set_default_weight\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wt:  The weight to set as the default. \n"
		""},
	 { "delete_ValueMapPostingSource", _wrap_delete_ValueMapPostingSource, METH_O, NULL},
	 { "ValueMapPostingSource_swigregister", ValueMapPostingSource_swigregister, METH_O, NULL},
	 { "ValueMapPostingSource_swiginit", ValueMapPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_FixedWeightPostingSource", _wrap_new_FixedWeightPostingSource, METH_O, "\n"
		"\n"
		"\n"
		"Construct a FixedWeightPostingSource.\n"
		"\n"
		"Xapian::FixedWeightPostingSource::FixedWeightPostingSource(double wt)\n"
		"Xapian::FixedWeightPostingSource::FixedWeightPostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"wt:  The fixed weight to return. \n"
		""},
	 { "delete_FixedWeightPostingSource", _wrap_delete_FixedWeightPostingSource, METH_O, NULL},
	 { "FixedWeightPostingSource_swigregister", FixedWeightPostingSource_swigregister, METH_O, NULL},
	 { "FixedWeightPostingSource_swiginit", FixedWeightPostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_MatchSpy", _wrap_new_MatchSpy, METH_O, "\n"
		"\n"
		"\n"
		"Default constructor, needed by subclass constructors.\n"
		"\n"
		"Xapian::MatchSpy::MatchSpy() noexcept Xapian::MatchSpy::MatchSpy\n"
		""},
	 { "delete_MatchSpy", _wrap_delete_MatchSpy, METH_O, "\n"
		"\n"
		"\n"
		"Virtual destructor, because we have virtual methods.\n"
		"\n"
		"virtual Xapian::MatchSpy::~MatchSpy() Xapian::MatchSpy::~MatchSpy\n"
		""},
	 { "MatchSpy___call__", _wrap_MatchSpy___call__, METH_VARARGS, NULL},
	 { "MatchSpy_name", _wrap_MatchSpy_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the name of this match spy.\n"
		"\n"
		"virtual std::string Xapian::MatchSpy::name() const\n"
		"Xapian::MatchSpy::name This name is used by the remote backend. It is\n"
		"passed with the serialised parameters to the remote server so that it\n"
		"knows which class to create.\n"
		"\n"
		"Return the full namespace-qualified name of your class here - if your\n"
		"class is called MyApp::FooMatchSpy, return \"MyApp::FooMatchSpy\" from\n"
		"this method.\n"
		"\n"
		"If you don't want to support the remote backend in your match spy, you\n"
		"can use the default implementation which simply throws\n"
		"Xapian::UnimplementedError. \n"
		""},
	 { "MatchSpy_merge_results", _wrap_MatchSpy_merge_results, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unserialise some results, and merge them into this matchspy.\n"
		"\n"
		"virtual void Xapian::MatchSpy::merge_results(const std::string\n"
		"&serialised) Xapian::MatchSpy::merge_results The order in which\n"
		"results are merged should not be significant, since this order is not\n"
		"specified (and will vary depending on the speed of the search in each\n"
		"sub-database).\n"
		"\n"
		"If you don't want to support the remote backend in your match spy, you\n"
		"can use the default implementation which simply throws\n"
		"Xapian::UnimplementedError.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"serialised:  A string containing the serialised results. \n"
		""},
	 { "MatchSpy___str__", _wrap_MatchSpy___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::MatchSpy::get_description() const\n"
		"Xapian::MatchSpy::get_description This default implementation returns\n"
		"a generic answer, to avoid forcing those deriving their own MatchSpy\n"
		"subclasses from having to implement this (they may not care what\n"
		"get_description() gives for their subclass). \n"
		""},
	 { "MatchSpy_release", _wrap_MatchSpy_release, METH_O, "\n"
		"\n"
		"\n"
		"Start reference counting this object.\n"
		"\n"
		"const MatchSpy * Xapian::MatchSpy::release() const\n"
		"Xapian::MatchSpy::release You can transfer ownership of a dynamically\n"
		"allocated MatchSpy object to Xapian by calling release() and then\n"
		"passing the object to a Xapian method. Xapian will arrange to delete\n"
		"the object once it is no longer required. \n"
		""},
	 { "disown_MatchSpy", _wrap_disown_MatchSpy, METH_O, NULL},
	 { "MatchSpy_swigregister", MatchSpy_swigregister, METH_O, NULL},
	 { "MatchSpy_swiginit", MatchSpy_swiginit, METH_VARARGS, NULL},
	 { "new_ValueCountMatchSpy", _wrap_new_ValueCountMatchSpy, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a MatchSpy which counts the values in a particular slot.\n"
		"\n"
		"Xapian::ValueCountMatchSpy::ValueCountMatchSpy(Xapian::valueno slot_)\n"
		"Xapian::ValueCountMatchSpy::ValueCountMatchSpy\n"
		""},
	 { "ValueCountMatchSpy_get_total", _wrap_ValueCountMatchSpy_get_total, METH_O, "\n"
		"\n"
		"\n"
		"Return the total number of documents tallied.\n"
		"\n"
		"size_t Xapian::ValueCountMatchSpy::get_total() const noexcept\n"
		"Xapian::ValueCountMatchSpy::get_total\n"
		""},
	 { "ValueCountMatchSpy_values_begin", _wrap_ValueCountMatchSpy_values_begin, METH_O, "\n"
		"\n"
		"\n"
		"Get an iterator over the values seen in the slot.\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::values_begin() const\n"
		"Xapian::ValueCountMatchSpy::values_begin Items will be returned in\n"
		"ascending alphabetical order.\n"
		"\n"
		"During the iteration, the frequency of the current value can be\n"
		"obtained with the get_termfreq() method on the iterator. \n"
		""},
	 { "ValueCountMatchSpy_values_end", _wrap_ValueCountMatchSpy_values_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to values_begin().\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::values_end() const noexcept\n"
		"Xapian::ValueCountMatchSpy::values_end\n"
		""},
	 { "ValueCountMatchSpy_top_values_begin", _wrap_ValueCountMatchSpy_top_values_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get an iterator over the most frequent values seen in the slot.\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::top_values_begin(size_t\n"
		"maxvalues) const Xapian::ValueCountMatchSpy::top_values_begin Items\n"
		"will be returned in descending order of frequency. Values with the\n"
		"same frequency will be returned in ascending alphabetical order.\n"
		"\n"
		"During the iteration, the frequency of the current value can be\n"
		"obtained with the get_termfreq() method on the iterator.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"maxvalues:  The maximum number of values to return. \n"
		""},
	 { "ValueCountMatchSpy_top_values_end", _wrap_ValueCountMatchSpy_top_values_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to top_values_begin().\n"
		"\n"
		"TermIterator Xapian::ValueCountMatchSpy::top_values_end(size_t) const\n"
		"noexcept Xapian::ValueCountMatchSpy::top_values_end\n"
		""},
	 { "delete_ValueCountMatchSpy", _wrap_delete_ValueCountMatchSpy, METH_O, NULL},
	 { "ValueCountMatchSpy_swigregister", ValueCountMatchSpy_swigregister, METH_O, NULL},
	 { "ValueCountMatchSpy_swiginit", ValueCountMatchSpy_swiginit, METH_VARARGS, NULL},
	 { "miles_to_metres", _wrap_miles_to_metres, METH_O, NULL},
	 { "metres_to_miles", _wrap_metres_to_miles, METH_O, NULL},
	 { "LatLongCoord_latitude_set", _wrap_LatLongCoord_latitude_set, METH_VARARGS, NULL},
	 { "LatLongCoord_latitude_get", _wrap_LatLongCoord_latitude_get, METH_O, NULL},
	 { "LatLongCoord_longitude_set", _wrap_LatLongCoord_longitude_set, METH_VARARGS, NULL},
	 { "LatLongCoord_longitude_get", _wrap_LatLongCoord_longitude_get, METH_O, NULL},
	 { "new_LatLongCoord", _wrap_new_LatLongCoord, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a coordinate.\n"
		"\n"
		"Xapian::LatLongCoord::LatLongCoord(double latitude_, double\n"
		"longitude_) Xapian::LatLongCoord::LatLongCoord If the supplied\n"
		"longitude is out of the standard range, it will be normalised to the\n"
		"range 0 <= longitude < 360.\n"
		"\n"
		"If you want to avoid the checks (for example, you know that your\n"
		"values are already in range), you can use the alternate constructor to\n"
		"construct an uninitialised coordinate, and then set the latitude and\n"
		"longitude directly.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"InvalidArgumentError:  the supplied latitude is out of range. \n"
		""},
	 { "LatLongCoord_unserialise", _wrap_LatLongCoord_unserialise, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unserialise a buffer and set this object to its coordinate.\n"
		"\n"
		"void Xapian::LatLongCoord::unserialise(const char **ptr, const char\n"
		"*end) Xapian::LatLongCoord::unserialise The buffer may contain further\n"
		"data after that for the coordinate.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"ptr:  A pointer to the start of the string. This will be updated to\n"
		"point to the end of the data representing the coordinate.\n"
		"\n"
		"end:  A pointer to the end of the string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::SerialisationError:  if the string does not start with a valid\n"
		"serialised latitude- longitude pair. \n"
		""},
	 { "LatLongCoord_serialise", _wrap_LatLongCoord_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Return a serialised representation of the coordinate.\n"
		"\n"
		"std::string Xapian::LatLongCoord::serialise() const\n"
		"Xapian::LatLongCoord::serialise\n"
		""},
	 { "LatLongCoord___str__", _wrap_LatLongCoord___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::LatLongCoord::get_description() const\n"
		"Xapian::LatLongCoord::get_description\n"
		""},
	 { "delete_LatLongCoord", _wrap_delete_LatLongCoord, METH_O, NULL},
	 { "LatLongCoord_swigregister", LatLongCoord_swigregister, METH_O, NULL},
	 { "LatLongCoord_swiginit", LatLongCoord_swiginit, METH_VARARGS, NULL},
	 { "new_LatLongCoordsIterator", _wrap_new_LatLongCoordsIterator, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Default constructor. Produces an uninitialised iterator.\n"
		"\n"
		"Xapian::LatLongCoordsIterator::LatLongCoordsIterator()\n"
		"Xapian::LatLongCoordsIterator::LatLongCoordsIterator\n"
		""},
	 { "LatLongCoordsIterator___eq__", _wrap_LatLongCoordsIterator___eq__, METH_VARARGS, NULL},
	 { "LatLongCoordsIterator_equals", _wrap_LatLongCoordsIterator_equals, METH_VARARGS, NULL},
	 { "LatLongCoordsIterator_get_coord", _wrap_LatLongCoordsIterator_get_coord, METH_O, NULL},
	 { "LatLongCoordsIterator___next__", _wrap_LatLongCoordsIterator___next__, METH_O, NULL},
	 { "delete_LatLongCoordsIterator", _wrap_delete_LatLongCoordsIterator, METH_O, NULL},
	 { "LatLongCoordsIterator_swigregister", LatLongCoordsIterator_swigregister, METH_O, NULL},
	 { "LatLongCoordsIterator_swiginit", LatLongCoordsIterator_swiginit, METH_VARARGS, NULL},
	 { "LatLongCoords_begin", _wrap_LatLongCoords_begin, METH_O, "\n"
		"\n"
		"\n"
		"Get a begin iterator for the coordinates.\n"
		"\n"
		"LatLongCoordsIterator Xapian::LatLongCoords::begin() const\n"
		"Xapian::LatLongCoords::begin\n"
		""},
	 { "LatLongCoords_end", _wrap_LatLongCoords_end, METH_O, "\n"
		"\n"
		"\n"
		"Get an end iterator for the coordinates.\n"
		"\n"
		"LatLongCoordsIterator Xapian::LatLongCoords::end() const\n"
		"Xapian::LatLongCoords::end\n"
		""},
	 { "LatLongCoords_size", _wrap_LatLongCoords_size, METH_O, "\n"
		"\n"
		"\n"
		"Get the number of coordinates in the container.\n"
		"\n"
		"size_t Xapian::LatLongCoords::size() const\n"
		"Xapian::LatLongCoords::size\n"
		""},
	 { "LatLongCoords_empty", _wrap_LatLongCoords_empty, METH_O, "\n"
		"\n"
		"\n"
		"Return true if and only if there are no coordinates in the container.\n"
		"\n"
		"bool Xapian::LatLongCoords::empty() const\n"
		"Xapian::LatLongCoords::empty\n"
		""},
	 { "LatLongCoords_append", _wrap_LatLongCoords_append, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Append a coordinate to the end of the sequence.\n"
		"\n"
		"void Xapian::LatLongCoords::append(const LatLongCoord &coord)\n"
		"Xapian::LatLongCoords::append\n"
		""},
	 { "new_LatLongCoords", _wrap_new_LatLongCoords, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a container holding one coordinate.\n"
		"\n"
		"Xapian::LatLongCoords::LatLongCoords(const LatLongCoord &coord)\n"
		"Xapian::LatLongCoords::LatLongCoords\n"
		""},
	 { "LatLongCoords_unserialise", _wrap_LatLongCoords_unserialise, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Unserialise a string and set this object to the coordinates in it.\n"
		"\n"
		"void Xapian::LatLongCoords::unserialise(std::string_view serialised)\n"
		"Xapian::LatLongCoords::unserialise\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"serialised:  the string to unserialise the coordinates from.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::SerialisationError:  if the string does not contain a valid\n"
		"serialised latitude-longitude pair, or contains junk at the end of it.\n"
		"\n"
		""},
	 { "LatLongCoords_serialise", _wrap_LatLongCoords_serialise, METH_O, "\n"
		"\n"
		"\n"
		"Return a serialised form of the coordinate list.\n"
		"\n"
		"std::string Xapian::LatLongCoords::serialise() const\n"
		"Xapian::LatLongCoords::serialise\n"
		""},
	 { "LatLongCoords___str__", _wrap_LatLongCoords___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"std::string Xapian::LatLongCoords::get_description() const\n"
		"Xapian::LatLongCoords::get_description\n"
		""},
	 { "delete_LatLongCoords", _wrap_delete_LatLongCoords, METH_O, NULL},
	 { "LatLongCoords_swigregister", LatLongCoords_swigregister, METH_O, NULL},
	 { "LatLongCoords_swiginit", LatLongCoords_swiginit, METH_VARARGS, NULL},
	 { "__ne__", _wrap___ne__, METH_VARARGS, NULL},
	 { "delete_LatLongMetric", _wrap_delete_LatLongMetric, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::LatLongMetric::~LatLongMetric()\n"
		"Xapian::LatLongMetric::~LatLongMetric\n"
		""},
	 { "LatLongMetric_pointwise_distance", _wrap_LatLongMetric_pointwise_distance, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return the distance between two coordinates, in metres.\n"
		"\n"
		"virtual double Xapian::LatLongMetric::pointwise_distance(const\n"
		"LatLongCoord &a, const LatLongCoord &b) const =0\n"
		"Xapian::LatLongMetric::pointwise_distance\n"
		""},
	 { "LatLongMetric___call__", _wrap_LatLongMetric___call__, METH_VARARGS, NULL},
	 { "LatLongMetric_name", _wrap_LatLongMetric_name, METH_O, "\n"
		"\n"
		"\n"
		"Return the full name of the metric.\n"
		"\n"
		"virtual std::string Xapian::LatLongMetric::name() const =0\n"
		"Xapian::LatLongMetric::name This is used when serialising and\n"
		"unserialising metrics; for example, for performing remote searches.\n"
		"\n"
		"If the subclass is in a C++ namespace, the namespace should be\n"
		"included in the name, using \"::\" as a separator. For example, for a\n"
		"LatLongMetric subclass called \"FooLatLongMetric\" in the \"Xapian\"\n"
		"namespace the result of this call should be\n"
		"\"Xapian::FooLatLongMetric\". \n"
		""},
	 { "new_LatLongMetric", _wrap_new_LatLongMetric, METH_O, NULL},
	 { "disown_LatLongMetric", _wrap_disown_LatLongMetric, METH_O, NULL},
	 { "LatLongMetric_swigregister", LatLongMetric_swigregister, METH_O, NULL},
	 { "LatLongMetric_swiginit", LatLongMetric_swiginit, METH_VARARGS, NULL},
	 { "new_GreatCircleMetric", _wrap_new_GreatCircleMetric, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a GreatCircleMetric using a specified radius.\n"
		"\n"
		"Xapian::GreatCircleMetric::GreatCircleMetric(double radius_)\n"
		"Xapian::GreatCircleMetric::GreatCircleMetric This is useful for data\n"
		"sets in which the points are not on Earth (eg, a database of features\n"
		"on Mars).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"radius_:  The radius of the sphere to use, in metres. \n"
		""},
	 { "delete_GreatCircleMetric", _wrap_delete_GreatCircleMetric, METH_O, NULL},
	 { "GreatCircleMetric_swigregister", GreatCircleMetric_swigregister, METH_O, NULL},
	 { "GreatCircleMetric_swiginit", GreatCircleMetric_swiginit, METH_VARARGS, NULL},
	 { "new_LatLongDistancePostingSource", _wrap_new_LatLongDistancePostingSource, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a new posting source which returns only documents within\n"
		"range of one of the central coordinates.\n"
		"\n"
		"Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource(Xapian::valueno\n"
		"slot_, const LatLongCoords &centre_, double max_range_=0.0, double\n"
		"k1_=1000.0, double k2_=1.0)\n"
		"Xapian::LatLongDistancePostingSource::LatLongDistancePostingSource\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  The value slot to read values from.\n"
		"\n"
		"centre_:  The centre point to use for distance calculations.\n"
		"\n"
		"max_range_:  The maximum distance for documents which are returned.\n"
		"\n"
		"k1_:  The k1 constant to use in the weighting function.\n"
		"\n"
		"k2_:  The k2 constant to use in the weighting function.\n"
		"\n"
		"Xapian::GreatCircleMetric is used as the metric. \n"
		""},
	 { "delete_LatLongDistancePostingSource", _wrap_delete_LatLongDistancePostingSource, METH_O, "\n"
		"Xapian::LatLongDistancePostingSource::~LatLongDistancePostingSource()\n"
		"Xapian::LatLongDistancePostingSource::~LatLongDistancePostingSource\n"
		""},
	 { "LatLongDistancePostingSource_swigregister", LatLongDistancePostingSource_swigregister, METH_O, NULL},
	 { "LatLongDistancePostingSource_swiginit", LatLongDistancePostingSource_swiginit, METH_VARARGS, NULL},
	 { "new_LatLongDistanceKeyMaker", _wrap_new_LatLongDistanceKeyMaker, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a LatLongDistanceKeyMaker.\n"
		"\n"
		"Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker(Xapian::valueno\n"
		"slot_, const LatLongCoord &centre_)\n"
		"Xapian::LatLongDistanceKeyMaker::LatLongDistanceKeyMaker\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot_:  Value slot to use.\n"
		"\n"
		"centre_:   Point to calculate distance from.\n"
		"\n"
		"Xapian::GreatCircleMetric is used as the metric.\n"
		"\n"
		"Documents where no value is set are assumed to be a large distance\n"
		"away. \n"
		""},
	 { "delete_LatLongDistanceKeyMaker", _wrap_delete_LatLongDistanceKeyMaker, METH_O, "\n"
		"Xapian::LatLongDistanceKeyMaker::~LatLongDistanceKeyMaker()\n"
		"Xapian::LatLongDistanceKeyMaker::~LatLongDistanceKeyMaker\n"
		""},
	 { "LatLongDistanceKeyMaker_swigregister", LatLongDistanceKeyMaker_swigregister, METH_O, NULL},
	 { "LatLongDistanceKeyMaker_swiginit", LatLongDistanceKeyMaker_swiginit, METH_VARARGS, NULL},
	 { "Database_add_database", _wrap_Database_add_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add shards from another Database.\n"
		"\n"
		"void Xapian::Database::add_database(const Database &other)\n"
		"Xapian::Database::add_database Any shards in other are appended to the\n"
		"list of shards in this object. The shards are reference counted and\n"
		"also remain in other.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"other:  Another Database to add shards from\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  if other is the same object as this. \n"
		""},
	 { "Database_size", _wrap_Database_size, METH_O, "\n"
		"\n"
		"\n"
		"Return number of shards in this Database object.\n"
		"\n"
		"size_t Xapian::Database::size() const Xapian::Database::size If you\n"
		"want the number of documents, see @ get_doccount().\n"
		"\n"
		"Xapian 1.4.12 \n"
		""},
	 { "new_Database", _wrap_new_Database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Move constructor.\n"
		"\n"
		"Xapian::Database::Database(Database &&o) Xapian::Database::Database\n"
		""},
	 { "delete_Database", _wrap_delete_Database, METH_O, "\n"
		"\n"
		"\n"
		"Destructor.\n"
		"\n"
		"virtual Xapian::Database::~Database() Xapian::Database::~Database\n"
		""},
	 { "Database_reopen", _wrap_Database_reopen, METH_O, "\n"
		"\n"
		"\n"
		"Reopen the database at the latest available revision.\n"
		"\n"
		"bool Xapian::Database::reopen() Xapian::Database::reopen  Xapian\n"
		"databases (at least with most backends) support versioning such that a\n"
		"Database object uses a snapshot of the database. However, write\n"
		"operations may cause this snapshot to be discarded, which can cause\n"
		"Xapian::DatabaseModifiedError to be thrown. You can recover from this\n"
		"situation by calling reopen() and restarting the search operation.\n"
		"\n"
		"All shards are updated to the latest available revision. This should\n"
		"be a cheap operation if they're already at the latest revision, so if\n"
		"you're using the same Database object for many searches it's\n"
		"reasonable to call reopen() before each search.\n"
		"\n"
		"true if one or more shards have moved to a newer revision (if false is\n"
		"returned then it's definitely the case that no shards were reopened,\n"
		"which applications may find useful when caching results, etc). In\n"
		"Xapian < 1.3.0, this method did not return a value.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::DatabaseError:  is thrown if close() has been called on any of\n"
		"the shards. \n"
		""},
	 { "Database_close", _wrap_Database_close, METH_O, "\n"
		"\n"
		"\n"
		"Close the database.\n"
		"\n"
		"void Xapian::Database::close() Xapian::Database::close This closes the\n"
		"database and closes all its file handles.\n"
		"\n"
		"For a WritableDatabase, if a transaction is active it will be aborted,\n"
		"while if no transaction is active commit() will be implicitly called.\n"
		"Also the write lock is released.\n"
		"\n"
		"Calling close() on an object cannot be undone - in particular, a\n"
		"subsequent call to reopen() on the same object will not reopen it, but\n"
		"will instead throw a Xapian::DatabaseClosedError exception.\n"
		"\n"
		"Calling close() again on an object which has already been closed has\n"
		"no effect (and doesn't raise an exception).\n"
		"\n"
		"After close() has been called, calls to other methods of the database,\n"
		"and to methods of other objects associated with the database, will\n"
		"either:\n"
		"\n"
		"behave exactly as they would have done if the database had not been\n"
		"closed (this can only happen if all the required data is cached)\n"
		"\n"
		"raise a Xapian::DatabaseClosedError exception.\n"
		"\n"
		"The reason for this behaviour is that otherwise we'd have to check\n"
		"that the database is still open on every method call on every object\n"
		"associated with a Database, when in many cases they are working on\n"
		"data which has already been loaded and so they are able to just behave\n"
		"correctly.\n"
		"\n"
		"This method was added in Xapian 1.1.0. \n"
		""},
	 { "Database___str__", _wrap_Database___str__, METH_O, "\n"
		"\n"
		"\n"
		"Return a string describing this object.\n"
		"\n"
		"virtual std::string Xapian::Database::get_description() const\n"
		"Xapian::Database::get_description\n"
		""},
	 { "Database__postlist_begin", _wrap_Database__postlist_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating the postings of a term.\n"
		"\n"
		"PostingIterator Xapian::Database::postlist_begin(std::string_view\n"
		"term) const Xapian::Database::postlist_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to iterate the postings of. An empty string acts as a\n"
		"special pseudo-term which indexes all the documents in the database\n"
		"with a wdf of 1. \n"
		""},
	 { "Database__postlist_end", _wrap_Database__postlist_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to postlist_begin().\n"
		"\n"
		"PostingIterator Xapian::Database::postlist_end(std::string_view) const\n"
		"noexcept Xapian::Database::postlist_end\n"
		""},
	 { "Database__termlist_begin", _wrap_Database__termlist_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating the terms in a document.\n"
		"\n"
		"TermIterator Xapian::Database::termlist_begin(Xapian::docid did) const\n"
		"Xapian::Database::termlist_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id to iterate terms from\n"
		"\n"
		"The terms are returned in ascending string order (by byte value). \n"
		""},
	 { "Database__termlist_end", _wrap_Database__termlist_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to termlist_begin().\n"
		"\n"
		"TermIterator Xapian::Database::termlist_end(Xapian::docid) const\n"
		"noexcept Xapian::Database::termlist_end\n"
		""},
	 { "Database_has_positions", _wrap_Database_has_positions, METH_O, "\n"
		"\n"
		"\n"
		"Does this database have any positional information?\n"
		"\n"
		"bool Xapian::Database::has_positions() const\n"
		"Xapian::Database::has_positions\n"
		""},
	 { "Database__positionlist_begin", _wrap_Database__positionlist_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating positions for a term in a document.\n"
		"\n"
		"PositionIterator Xapian::Database::positionlist_begin(Xapian::docid\n"
		"did, std::string_view term) const Xapian::Database::positionlist_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"term:  The term\n"
		"\n"
		"1.1.0 If the specified document doesn't exist or the specified term\n"
		"doesn't exist in the specified document, then a valid iterator is\n"
		"still returned, but it will be equal to positionlist_end(). \n"
		""},
	 { "Database__positionlist_end", _wrap_Database__positionlist_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to positionlist_begin().\n"
		"\n"
		"PositionIterator Xapian::Database::positionlist_end(Xapian::docid,\n"
		"std::string_view) const noexcept Xapian::Database::positionlist_end\n"
		""},
	 { "Database__allterms_begin", _wrap_Database__allterms_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Start iterating all terms in the database with a given prefix.\n"
		"\n"
		"TermIterator Xapian::Database::allterms_begin(std::string_view\n"
		"prefix={}) const Xapian::Database::allterms_begin The terms are\n"
		"returned in ascending string order (by byte value).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix:  The prefix to restrict the returned terms to (default:\n"
		"iterate all terms) \n"
		""},
	 { "Database__allterms_end", _wrap_Database__allterms_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to allterms_begin(prefix).\n"
		"\n"
		"TermIterator Xapian::Database::allterms_end(std::string_view={}) const\n"
		"noexcept Xapian::Database::allterms_end\n"
		""},
	 { "Database_get_doccount", _wrap_Database_get_doccount, METH_O, "\n"
		"\n"
		"\n"
		"Get the number of documents in the database.\n"
		"\n"
		"Xapian::doccount Xapian::Database::get_doccount() const\n"
		"Xapian::Database::get_doccount\n"
		""},
	 { "Database_get_lastdocid", _wrap_Database_get_lastdocid, METH_O, "\n"
		"\n"
		"\n"
		"Get the highest document id which has been used in the database.\n"
		"\n"
		"Xapian::docid Xapian::Database::get_lastdocid() const\n"
		"Xapian::Database::get_lastdocid\n"
		""},
	 { "Database_get_average_length", _wrap_Database_get_average_length, METH_O, "\n"
		"\n"
		"\n"
		"Get the mean document length in the database.\n"
		"\n"
		"double Xapian::Database::get_average_length() const\n"
		"Xapian::Database::get_average_length\n"
		""},
	 { "Database_get_avlength", _wrap_Database_get_avlength, METH_O, "\n"
		"\n"
		"\n"
		"Old name for get_average_length() for backward compatibility.\n"
		"\n"
		"double Xapian::Database::get_avlength() const\n"
		"Xapian::Database::get_avlength\n"
		""},
	 { "Database_get_total_length", _wrap_Database_get_total_length, METH_O, "\n"
		"\n"
		"\n"
		"Get the total length of all the documents in the database.\n"
		"\n"
		"Xapian::totallength Xapian::Database::get_total_length() const\n"
		"Xapian::Database::get_total_length\n"
		"\n"
		"Added in Xapian 1.4.5. \n"
		""},
	 { "Database_get_termfreq", _wrap_Database_get_termfreq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the number of documents indexed by a specified term.\n"
		"\n"
		"Xapian::doccount Xapian::Database::get_termfreq(std::string_view term)\n"
		"const Xapian::Database::get_termfreq\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to get the frequency of. An empty string acts as a\n"
		"special pseudo-term which indexes all the documents in the database,\n"
		"so returns get_doccount(). If the term isn't present in the database,\n"
		"0 is returned. \n"
		""},
	 { "Database_term_exists", _wrap_Database_term_exists, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Test is a particular term is present in any document.\n"
		"\n"
		"bool Xapian::Database::term_exists(std::string_view term) const\n"
		"Xapian::Database::term_exists\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to test for. An empty string acts as a special pseudo-\n"
		"term which indexes all the documents in the database, so returns true\n"
		"if the database contains any documents.\n"
		"\n"
		"db.term_exists(t) gives the same answer as db.get_termfreq(t) != 0,\n"
		"but is typically more efficient. \n"
		""},
	 { "Database_get_collection_freq", _wrap_Database_get_collection_freq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the total number of occurrences of a specified term.\n"
		"\n"
		"Xapian::termcount\n"
		"Xapian::Database::get_collection_freq(std::string_view term) const\n"
		"Xapian::Database::get_collection_freq The collection frequency of a\n"
		"term is defined as the total number of times it occurs in the\n"
		"database, which is the sum of its wdf in all the documents it indexes.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to get the collection frequency of. An empty string\n"
		"acts as a special pseudo-term which indexes all the documents in the\n"
		"database, so returns get_doccount(). If the term isn't present in the\n"
		"database, 0 is returned. \n"
		""},
	 { "Database_get_value_freq", _wrap_Database_get_value_freq, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return the frequency of a given value slot.\n"
		"\n"
		"Xapian::doccount Xapian::Database::get_value_freq(Xapian::valueno\n"
		"slot) const Xapian::Database::get_value_freq This is the number of\n"
		"documents which have a (non-empty) value stored in the slot.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to examine. \n"
		""},
	 { "Database_get_value_lower_bound", _wrap_Database_get_value_lower_bound, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a lower bound on the values stored in the given value slot.\n"
		"\n"
		"std::string Xapian::Database::get_value_lower_bound(Xapian::valueno\n"
		"slot) const Xapian::Database::get_value_lower_bound If there are no\n"
		"values stored in the given value slot, this will return an empty\n"
		"string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to examine. \n"
		""},
	 { "Database_get_value_upper_bound", _wrap_Database_get_value_upper_bound, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get an upper bound on the values stored in the given value slot.\n"
		"\n"
		"std::string Xapian::Database::get_value_upper_bound(Xapian::valueno\n"
		"slot) const Xapian::Database::get_value_upper_bound If there are no\n"
		"values stored in the given value slot, this will return an empty\n"
		"string.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"slot:  The value slot to examine. \n"
		""},
	 { "Database_get_doclength_lower_bound", _wrap_Database_get_doclength_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get a lower bound on the length of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_doclength_lower_bound() const\n"
		"Xapian::Database::get_doclength_lower_bound This bound does not\n"
		"include any zero-length documents. \n"
		""},
	 { "Database_get_doclength_upper_bound", _wrap_Database_get_doclength_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get an upper bound on the length of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_doclength_upper_bound() const\n"
		"Xapian::Database::get_doclength_upper_bound\n"
		""},
	 { "Database_get_wdf_upper_bound", _wrap_Database_get_wdf_upper_bound, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get an upper bound on the wdf of term term.\n"
		"\n"
		"Xapian::termcount\n"
		"Xapian::Database::get_wdf_upper_bound(std::string_view term) const\n"
		"Xapian::Database::get_wdf_upper_bound\n"
		""},
	 { "Database_get_unique_terms_lower_bound", _wrap_Database_get_unique_terms_lower_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get a lower bound on the unique terms size of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_unique_terms_lower_bound()\n"
		"const Xapian::Database::get_unique_terms_lower_bound\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_get_unique_terms_upper_bound", _wrap_Database_get_unique_terms_upper_bound, METH_O, "\n"
		"\n"
		"\n"
		"Get an upper bound on the unique terms size of a document in this DB.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_unique_terms_upper_bound()\n"
		"const Xapian::Database::get_unique_terms_upper_bound\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_valuestream_begin", _wrap_Database_valuestream_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return an iterator over the value in slot slot for each document.\n"
		"\n"
		"ValueIterator Xapian::Database::valuestream_begin(Xapian::valueno\n"
		"slot) const Xapian::Database::valuestream_begin\n"
		""},
	 { "Database_valuestream_end", _wrap_Database_valuestream_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Return end iterator corresponding to valuestream_begin().\n"
		"\n"
		"ValueIterator Xapian::Database::valuestream_end(Xapian::valueno) const\n"
		"noexcept Xapian::Database::valuestream_end\n"
		""},
	 { "Database_get_doclength", _wrap_Database_get_doclength, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the length of a specified document.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_doclength(Xapian::docid did)\n"
		"const Xapian::Database::get_doclength\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"Xapian defines a document's length as the sum of the wdf of all the\n"
		"terms which index it. \n"
		""},
	 { "Database_get_unique_terms", _wrap_Database_get_unique_terms, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the number of unique terms in a specified document.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_unique_terms(Xapian::docid\n"
		"did) const Xapian::Database::get_unique_terms\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"This is the number of different terms which index the given document.\n"
		"\n"
		""},
	 { "Database_get_wdfdocmax", _wrap_Database_get_wdfdocmax, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the maximum wdf value in a specified document.\n"
		"\n"
		"Xapian::termcount Xapian::Database::get_wdfdocmax(Xapian::docid did)\n"
		"const Xapian::Database::get_wdfdocmax\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_keep_alive", _wrap_Database_keep_alive, METH_O, "\n"
		"\n"
		"\n"
		"Send a keep-alive message.\n"
		"\n"
		"void Xapian::Database::keep_alive() Xapian::Database::keep_alive For\n"
		"remote databases, this method sends a message to the server to reset\n"
		"the timeout timer. As well as preventing timeouts at the Xapian remote\n"
		"protocol level, this message will also avoid timeouts at lower levels.\n"
		"\n"
		"For local databases, this method does nothing. \n"
		""},
	 { "Database_get_document", _wrap_Database_get_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get a document from the database.\n"
		"\n"
		"Xapian::Document Xapian::Database::get_document(Xapian::docid did,\n"
		"unsigned flags=0) const Xapian::Database::get_document The returned\n"
		"object acts as a handle which lazily fetches information about the\n"
		"specified document from the database.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document ID of the document to be get\n"
		"\n"
		"flags:  Zero or more flags bitwise-or-ed together (currently only\n"
		"Xapian::DOC_ASSUME_VALID is supported). (default: 0)\n"
		"\n"
		"The flags parameter was added in Xapian 2.0.0.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  is thrown if did is 0.\n"
		"\n"
		"Xapian::DocNotFoundError:  is thrown if the specified docid is not\n"
		"present in this database. \n"
		""},
	 { "Database_get_spelling_suggestion", _wrap_Database_get_spelling_suggestion, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Suggest a spelling correction.\n"
		"\n"
		"std::string Xapian::Database::get_spelling_suggestion(std::string_view\n"
		"word, unsigned max_edit_distance=2) const\n"
		"Xapian::Database::get_spelling_suggestion\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"word:  The potentially misspelled word.\n"
		"\n"
		"max_edit_distance:  Only consider words which are at most\n"
		"max_edit_distance edits from word. An edit is a character insertion,\n"
		"deletion, or the transposition of two adjacent characters (default is\n"
		"2). \n"
		""},
	 { "Database__spellings_begin", _wrap_Database__spellings_begin, METH_O, "\n"
		"\n"
		"\n"
		"An iterator which returns all the spelling correction targets.\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::spellings_begin() const\n"
		"Xapian::Database::spellings_begin This returns all the words which are\n"
		"considered as targets for the spelling correction algorithm. The\n"
		"frequency of each word is available as the term frequency of each\n"
		"entry in the returned iterator. \n"
		""},
	 { "Database__spellings_end", _wrap_Database__spellings_end, METH_O, "\n"
		"\n"
		"\n"
		"End iterator corresponding to spellings_begin().\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::spellings_end() const noexcept\n"
		"Xapian::Database::spellings_end\n"
		""},
	 { "Database__synonyms_begin", _wrap_Database__synonyms_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An iterator which returns all the synonyms for a given term.\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::synonyms_begin(std::string_view\n"
		"term) const Xapian::Database::synonyms_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to return synonyms for. \n"
		""},
	 { "Database__synonyms_end", _wrap_Database__synonyms_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to synonyms_begin(term).\n"
		"\n"
		"Xapian::TermIterator Xapian::Database::synonyms_end(std::string_view)\n"
		"const noexcept Xapian::Database::synonyms_end\n"
		""},
	 { "Database__synonym_keys_begin", _wrap_Database__synonym_keys_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An iterator which returns all terms which have synonyms.\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::synonym_keys_begin(std::string_view prefix={}) const\n"
		"Xapian::Database::synonym_keys_begin\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix:  If non-empty, only terms with this prefix are returned. \n"
		""},
	 { "Database__synonym_keys_end", _wrap_Database__synonym_keys_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to synonym_keys_begin(prefix).\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::synonym_keys_end(std::string_view={}) const noexcept\n"
		"Xapian::Database::synonym_keys_end\n"
		""},
	 { "Database_get_metadata", _wrap_Database_get_metadata, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Get the user-specified metadata associated with a given key.\n"
		"\n"
		"std::string Xapian::Database::get_metadata(std::string_view key) const\n"
		"Xapian::Database::get_metadata User-specified metadata allows you to\n"
		"store arbitrary information in the form of (key, value) pairs. See\n"
		"WritableDatabase::set_metadata() for more information.\n"
		"\n"
		"When invoked on a Xapian::Database object representing multiple\n"
		"databases, currently only the metadata for the first is considered but\n"
		"this behaviour may change in the future.\n"
		"\n"
		"If there is no piece of metadata associated with the specified key, an\n"
		"empty string is returned (this applies even for backends which don't\n"
		"support metadata).\n"
		"\n"
		"Empty keys are not valid, and specifying one will cause an exception.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The key of the metadata item to access.\n"
		"\n"
		"The retrieved metadata item's value.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  will be thrown if the key supplied is\n"
		"empty. \n"
		""},
	 { "Database__metadata_keys_begin", _wrap_Database__metadata_keys_begin, METH_VARARGS, "\n"
		"\n"
		"\n"
		"An iterator which returns all user-specified metadata keys.\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::metadata_keys_begin(std::string_view prefix={})\n"
		"const Xapian::Database::metadata_keys_begin When invoked on a\n"
		"Xapian::Database object representing multiple databases, currently\n"
		"only the metadata for the first is considered but this behaviour may\n"
		"change in the future.\n"
		"\n"
		"If the backend doesn't support metadata, then this method returns an\n"
		"iterator which compares equal to that returned by metadata_keys_end().\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"prefix:  If non-empty, only keys with this prefix are returned.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  will be thrown if the backend implements\n"
		"user-specified metadata, but doesn't implement iterating its keys\n"
		"(currently this happens for the InMemory backend). \n"
		""},
	 { "Database__metadata_keys_end", _wrap_Database__metadata_keys_end, METH_VARARGS, "\n"
		"\n"
		"\n"
		"End iterator corresponding to metadata_keys_begin().\n"
		"\n"
		"Xapian::TermIterator\n"
		"Xapian::Database::metadata_keys_end(std::string_view={}) const\n"
		"noexcept Xapian::Database::metadata_keys_end\n"
		""},
	 { "Database_get_uuid", _wrap_Database_get_uuid, METH_O, "\n"
		"\n"
		"\n"
		"Get the UUID for the database.\n"
		"\n"
		"std::string Xapian::Database::get_uuid() const\n"
		"Xapian::Database::get_uuid The UUID will persist for the lifetime of\n"
		"the database.\n"
		"\n"
		"Replicas (eg, made with the replication protocol, or by copying all\n"
		"the database files) will have the same UUID. However, copies (made\n"
		"with copydatabase, or xapian-compact) will have different UUIDs.\n"
		"\n"
		"If the backend does not support UUIDs or this database has no\n"
		"subdatabases, the UUID will be empty.\n"
		"\n"
		"If this database has multiple sub-databases, the UUID string will\n"
		"contain the UUIDs of all the sub-databases separated by colons. \n"
		""},
	 { "Database_locked", _wrap_Database_locked, METH_O, "\n"
		"\n"
		"\n"
		"Test if this database is currently locked for writing.\n"
		"\n"
		"bool Xapian::Database::locked() const Xapian::Database::locked If the\n"
		"underlying object is actually a WritableDatabase, always returns true\n"
		"unless close() has been called.\n"
		"\n"
		"Otherwise tests if there's a writer holding the lock (or if we can't\n"
		"test for a lock without taking it on the current platform, throw\n"
		"Xapian::UnimplementedError). If there's an error while trying to test\n"
		"the lock, throws Xapian::DatabaseLockError.\n"
		"\n"
		"For multi-databases, this tests each sub-database and returns true if\n"
		"any of them are locked. \n"
		""},
	 { "Database_lock", _wrap_Database_lock, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Lock a read-only database for writing.\n"
		"\n"
		"Xapian::WritableDatabase Xapian::Database::lock(int flags=0)\n"
		"Xapian::Database::lock If the database is actually already writable\n"
		"(i.e. a WritableDatabase via a Database reference) then the same\n"
		"database is returned (with its flags updated, so this provides an\n"
		"efficient way to modify flags on an open WritableDatabase).\n"
		"\n"
		"Unlike unlock(), the object this is called on remains open.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"flags:  The flags to use for the writable database. Flags which\n"
		"specify how to open the database are ignored (e.g.\n"
		"DB_CREATE_OR_OVERWRITE doesn't result in the database being wiped),\n"
		"and flags which specify the backend are also ignored as they are only\n"
		"relevant when creating a new database.\n"
		"\n"
		"A WritableDatabase object open on the same database.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_unlock", _wrap_Database_unlock, METH_O, "\n"
		"\n"
		"\n"
		"Release a database write lock.\n"
		"\n"
		"Xapian::Database Xapian::Database::unlock() Xapian::Database::unlock\n"
		"If called on a read-only database then the same database is returned.\n"
		"\n"
		"If called on a writable database, the object this method was called on\n"
		"is closed.\n"
		"\n"
		"A Database object open on the same database.\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_get_revision", _wrap_Database_get_revision, METH_O, "\n"
		"\n"
		"\n"
		"Get the revision of the database.\n"
		"\n"
		"Xapian::rev Xapian::Database::get_revision() const\n"
		"Xapian::Database::get_revision The revision is an unsigned integer\n"
		"which increases with each commit. In practice it typically increments\n"
		"by one for each revision but you should not rely on that.\n"
		"\n"
		"Xapian 1.4.13 and later return 0 for a database consisting of no\n"
		"shards.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidOperationError:  If the database consists of more than\n"
		"one shard. In Xapian < 1.4.13, this is also thrown if the database\n"
		"consists of no shards.\n"
		"\n"
		"Xapian::UnimplementedError:  Currently this is only implemented for\n"
		"glass (and for chert in Xapian 1.4.x). \n"
		""},
	 { "Database_check", _wrap_Database_check, METH_VARARGS, NULL},
	 { "Database_compact", _wrap_Database_compact, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Produce a compact version of this database.\n"
		"\n"
		"void Xapian::Database::compact(int fd, unsigned flags, int block_size,\n"
		"Xapian::Compactor &compactor) Xapian::Database::compact The compactor\n"
		"functor allows handling progress output and specifying how user\n"
		"metadata is merged.\n"
		"\n"
		"This variant writes a single-file database to the specified file\n"
		"descriptor. Only the glass backend supports such databases, so this\n"
		"form is only supported for this backend.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"fd:  File descriptor to write the compact version to. The descriptor\n"
		"needs to be readable and writable (open with O_RDWR) and seekable. The\n"
		"current file offset is used, allowing compacting to a single file\n"
		"database embedded within another file. Xapian takes ownership of the\n"
		"file descriptor and will close it before returning.\n"
		"\n"
		"flags:  Any of the following combined using bitwise-or (| in C++):\n"
		"Xapian::DBCOMPACT_NO_RENUMBER By default the document ids will be\n"
		"renumbered the output - currently by applying the same offset to all\n"
		"the document ids in a particular source database. If this flag is\n"
		"specified, then this renumbering doesn't happen, but all the document\n"
		"ids must be unique over all source databases. Currently the ranges of\n"
		"document ids in each source must not overlap either, though this\n"
		"restriction may be removed in the future.\n"
		"\n"
		"Xapian::DBCOMPACT_MULTIPASS If merging more than 3 databases, merge\n"
		"the postlists in multiple passes, which is generally faster but\n"
		"requires more disk space for temporary files.\n"
		"\n"
		"Xapian::DBCOMPACT_SINGLE_FILE Produce a single-file database (only\n"
		"supported for glass currently).\n"
		"\n"
		"At most one of:  Xapian::Compactor::STANDARD - Don't split items\n"
		"unnecessarily.\n"
		"\n"
		"Xapian::Compactor::FULL - Split items whenever it saves space (the\n"
		"default).\n"
		"\n"
		"Xapian::Compactor::FULLER - Allow oversize items to save more space\n"
		"(not recommended if you ever plan to update the compacted database).\n"
		"\n"
		"1.4.31 Has the same effect as FULL.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"block_size:  This specifies the block size (in bytes) for to use for\n"
		"the output. For glass, the block size must be a power of 2 between\n"
		"2048 and 65536 (inclusive), and the default (also used if an invalid\n"
		"value is passed) is 8192 bytes.\n"
		"\n"
		"compactor:  Functor\n"
		"\n"
		"1.3.4 This method was added to replace various methods of the\n"
		"Compactor class. \n"
		""},
	 { "Database_reconstruct_text", _wrap_Database_reconstruct_text, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Reconstruct document text.\n"
		"\n"
		"std::string Xapian::Database::reconstruct_text(Xapian::docid did,\n"
		"size_t length=0, std::string_view prefix={}, Xapian::termpos\n"
		"start_pos=0, Xapian::termpos end_pos=0) const\n"
		"Xapian::Database::reconstruct_text This uses term positional\n"
		"information to reconstruct the document text which was indexed.\n"
		"Reading the required positional information is potentially quite I/O\n"
		"intensive.\n"
		"\n"
		"The reconstructed text will be missing punctuation and most\n"
		"capitalisation.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"did:  The document id of the document to reconstruct\n"
		"\n"
		"length:  Number of bytes of text to aim for - note that slightly more\n"
		"may be returned (default: 0 meaning unlimited)\n"
		"\n"
		"prefix:  Term prefix to reconstruct (default: none)\n"
		"\n"
		"start_pos:  First position to reconstruct (default: 0)\n"
		"\n"
		"end_pos:  Last position to reconstruct (default: 0 meaning all)\n"
		"\n"
		"Added in Xapian 2.0.0. \n"
		""},
	 { "Database_swigregister", Database_swigregister, METH_O, NULL},
	 { "Database_swiginit", Database_swiginit, METH_VARARGS, NULL},
	 { "WritableDatabase_add_database", _wrap_WritableDatabase_add_database, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add shards from another WritableDatabase.\n"
		"\n"
		"void Xapian::WritableDatabase::add_database(const WritableDatabase\n"
		"&other) Xapian::WritableDatabase::add_database Any shards in other are\n"
		"added to the list of shards in this object. The shards are reference\n"
		"counted and also remain in other.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"other:  Another WritableDatabase to add shards from\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::InvalidArgumentError:  if other is the same object as this. \n"
		""},
	 { "new_WritableDatabase", _wrap_new_WritableDatabase, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Move constructor.\n"
		"\n"
		"Xapian::WritableDatabase::WritableDatabase(WritableDatabase &&o)\n"
		"Xapian::WritableDatabase::WritableDatabase\n"
		""},
	 { "WritableDatabase_commit", _wrap_WritableDatabase_commit, METH_O, "\n"
		"\n"
		"\n"
		"Commit pending modifications.\n"
		"\n"
		"void Xapian::WritableDatabase::commit()\n"
		"Xapian::WritableDatabase::commit Updates to a Xapian database are more\n"
		"efficient when applied in bulk, so by default Xapian stores\n"
		"modifications in memory until a threshold is exceeded and then they\n"
		"are committed to disk.\n"
		"\n"
		"When the database is closed (by an explicit call to close() or its\n"
		"destructor being called) then commit() is implicitly called unless a\n"
		"transaction is active.\n"
		"\n"
		"You can force any such pending modifications to be committed by\n"
		"calling this method, but bear in mind that the batching happens for a\n"
		"reason and calling commit() a lot is likely to slow down indexing.\n"
		"\n"
		"If the commit operation succeeds then the changes are reliably written\n"
		"to disk and available to readers. If the commit operation fails, then\n"
		"any pending modifications are discarded.\n"
		"\n"
		"However, note that if called on a sharded database, atomicity isn't\n"
		"guaranteed between shards - it's possible for the changes to one shard\n"
		"to be committed but changes to another shard to fail.\n"
		"\n"
		"It's not valid to call commit() within a transaction - see\n"
		"begin_transaction() for more details of how transactions work in\n"
		"Xapian.\n"
		"\n"
		"Currently batched modifications are automatically committed every\n"
		"10000 documents added, deleted, or modified. This value is rather\n"
		"conservative, and if you have a machine with plenty of memory, you can\n"
		"improve indexing throughput dramatically by setting\n"
		"XAPIAN_FLUSH_THRESHOLD in the environment to a larger value.\n"
		"\n"
		"This method was new in Xapian 1.1.0 - in earlier versions it was\n"
		"called flush(). \n"
		""},
	 { "WritableDatabase_begin_transaction", _wrap_WritableDatabase_begin_transaction, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Begin a transaction.\n"
		"\n"
		"void Xapian::WritableDatabase::begin_transaction(bool flushed=true)\n"
		"Xapian::WritableDatabase::begin_transaction A Xapian transaction is a\n"
		"set of consecutive modifications to be committed as an atomic unit -\n"
		"in any committed revision of the database either none are present or\n"
		"they all are.\n"
		"\n"
		"However, note that if called on a sharded database, atomicity isn't\n"
		"guaranteed between shards. Within each shard, the transaction will\n"
		"still act atomically.\n"
		"\n"
		"A transaction is started with begin_transaction() and can either be\n"
		"completed by calling commit_transaction() or aborted by calling\n"
		"cancel_transaction().\n"
		"\n"
		"Closing the database (by an explicit call to close() or by its\n"
		"destructor being called) when a transaction is active will implicitly\n"
		"call cancel_transaction() to abort the transaction and discard the\n"
		"changes in it.\n"
		"\n"
		"By default, commit() is implicitly called by begin_transaction() and\n"
		"commit_transaction() so that the changes in the transaction are\n"
		"committed or not independent of changes before or after it.\n"
		"\n"
		"The downside of these implicit calls to commit() is that small\n"
		"transactions can harm indexing performance in the same way that\n"
		"explicitly calling commit() frequently can.\n"
		"\n"
		"If you're applying atomic groups of changes and only wish to ensure\n"
		"that each group is either applied or not applied, then you can prevent\n"
		"the automatic commit() before and after the transaction by starting\n"
		"the transaction with begin_transaction(false). However, if\n"
		"cancel_transaction() is called (or if commit_transaction() isn't\n"
		"called before the WritableDatabase object is destroyed) then any\n"
		"changes which were pending before the transaction began will also be\n"
		"discarded.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"flushed:  Is this a flushed transaction? By default transactions are\n"
		"\"flushed\", which means that committing a transaction will ensure\n"
		"those changes are permanently written to the database. By contrast,\n"
		"unflushed transactions only ensure that changes within the transaction\n"
		"are either all applied or all aren't.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  is thrown if this is an InMemory\n"
		"database, which don't currently support transactions.\n"
		"\n"
		"Xapian::InvalidOperationError:  will be thrown if a transaction is\n"
		"already active. \n"
		""},
	 { "WritableDatabase_commit_transaction", _wrap_WritableDatabase_commit_transaction, METH_O, "\n"
		"\n"
		"\n"
		"Complete the transaction currently in progress.\n"
		"\n"
		"void Xapian::WritableDatabase::commit_transaction()\n"
		"Xapian::WritableDatabase::commit_transaction If the transaction was\n"
		"begun as a flushed transaction then the changes in it have been\n"
		"committed to the database upon successful completion of this method.\n"
		"\n"
		"If an exception is thrown, then the changes in the transaction will be\n"
		"discarded (if the transaction was not begun as a flushed transaction,\n"
		"any changes made but not committed before begin_transaction() will\n"
		"also be discarded).\n"
		"\n"
		"In all cases the transaction will no longer be in progress.\n"
		"\n"
		"Note that if called on a sharded database, atomicity isn't guaranteed\n"
		"between shards. Within each shard, the transaction will still act\n"
		"atomically.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  is thrown if this is an InMemory\n"
		"database, which don't currently support transactions.\n"
		"\n"
		"Xapian::InvalidOperationError:  is thrown if no transaction was\n"
		"active. \n"
		""},
	 { "WritableDatabase_cancel_transaction", _wrap_WritableDatabase_cancel_transaction, METH_O, "\n"
		"\n"
		"\n"
		"Abort the transaction currently in progress.\n"
		"\n"
		"void Xapian::WritableDatabase::cancel_transaction()\n"
		"Xapian::WritableDatabase::cancel_transaction Changes made within the\n"
		"current transaction will be discarded (if the transaction was not\n"
		"begun as a flushed transaction, any changes made but not committed\n"
		"before begin_transaction() will also be discarded).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::UnimplementedError:  is thrown if this is an InMemory\n"
		"database, which don't currently support transactions.\n"
		"\n"
		"Xapian::InvalidOperationError:  is thrown if no transaction was\n"
		"active. \n"
		""},
	 { "WritableDatabase_add_document", _wrap_WritableDatabase_add_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a document to the database.\n"
		"\n"
		"Xapian::docid Xapian::WritableDatabase::add_document(const\n"
		"Xapian::Document &doc) Xapian::WritableDatabase::add_document The\n"
		"document is allocated document ID ( get_lastdocid() + 1) - the next\n"
		"highest document ID which has never previously been used by this\n"
		"database (so docids from deleted documents won't be reused).\n"
		"\n"
		"If you want to specify the document ID to be used, you should call\n"
		"replace_document() instead.\n"
		"\n"
		"If a transaction is active, the document addition is added to the\n"
		"transaction; otherwise it is added to the current batch of changes.\n"
		"Either way, it won't be visible to readers right away (unless we're\n"
		"not in a transaction and the addition triggers an automatic commit).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"doc:  The Document object to be added.\n"
		"\n"
		"The document ID allocated to the document. \n"
		""},
	 { "WritableDatabase_delete_document", _wrap_WritableDatabase_delete_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Delete any documents indexed by a term from the database.\n"
		"\n"
		"void Xapian::WritableDatabase::delete_document(std::string_view\n"
		"unique_term) Xapian::WritableDatabase::delete_document This method\n"
		"removes any documents indexed by the specified term from the database.\n"
		"\n"
		"A major use is for convenience when UIDs from another system are\n"
		"mapped to terms in Xapian, although this method has other uses (for\n"
		"example, you could add a \"deletion date\" term to documents at index\n"
		"time and use this method to delete all documents due for deletion on a\n"
		"particular date).\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"unique_term:  The term to remove references to.\n"
		"\n"
		"2.0.0 The changes made by this method are made atomically. Previously\n"
		"automatic commits could happen during the batch. \n"
		""},
	 { "WritableDatabase_replace_document", _wrap_WritableDatabase_replace_document, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Replace any documents matching a term.\n"
		"\n"
		"Xapian::docid\n"
		"Xapian::WritableDatabase::replace_document(std::string_view\n"
		"unique_term, const Xapian::Document &document)\n"
		"Xapian::WritableDatabase::replace_document This method replaces any\n"
		"documents indexed by the specified term with the specified document.\n"
		"If any documents are indexed by the term, the lowest document ID will\n"
		"be used for the document, otherwise a new document ID will be\n"
		"generated as for add_document.\n"
		"\n"
		"One common use is to allow UIDs from another system to easily be\n"
		"mapped to terms in Xapian. Note that this method doesn't automatically\n"
		"add unique_term as a term, so you'll need to call\n"
		"document.add_term(unique_term) first when using replace_document() in\n"
		"this way.\n"
		"\n"
		"Note that changes to the database won't be immediately committed to\n"
		"disk; see commit() for more details.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"unique_term:  The \"unique\" term.\n"
		"\n"
		"document:  The new document.\n"
		"\n"
		"The document ID used by the new document. If term existed in the\n"
		"database, this will be the first document ID that was indexed by that\n"
		"term; otherwise the database allocates ( get_lastdocid() + 1) as it\n"
		"does for add_document().\n"
		"\n"
		"2.0.0 The changes made by this method are made atomically. Previously\n"
		"automatic commits could happen during the batch. \n"
		""},
	 { "WritableDatabase_add_spelling", _wrap_WritableDatabase_add_spelling, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a word to the spelling dictionary.\n"
		"\n"
		"void Xapian::WritableDatabase::add_spelling(std::string_view word,\n"
		"Xapian::termcount freqinc=1) const\n"
		"Xapian::WritableDatabase::add_spelling If the word is already present,\n"
		"its frequency is increased.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"word:  The word to add.\n"
		"\n"
		"freqinc:  How much to increase its frequency by (default 1). \n"
		""},
	 { "WritableDatabase_remove_spelling", _wrap_WritableDatabase_remove_spelling, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a word from the spelling dictionary.\n"
		"\n"
		"termcount Xapian::WritableDatabase::remove_spelling(std::string_view\n"
		"word, termcount freqdec=1) const\n"
		"Xapian::WritableDatabase::remove_spelling The word's frequency is\n"
		"decreased, and if would become zero or less then the word is removed\n"
		"completely.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"word:  The word to remove.\n"
		"\n"
		"freqdec:  How much to decrease its frequency by (default 1).\n"
		"\n"
		"Any \"unused\" freqdec (if the word's frequency was less than freqdec\n"
		"then the difference is returned, else 0 is returned). Prior to 2.0.0\n"
		"this method had void return type. \n"
		""},
	 { "WritableDatabase_add_synonym", _wrap_WritableDatabase_add_synonym, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add a synonym for a term.\n"
		"\n"
		"void Xapian::WritableDatabase::add_synonym(std::string_view term,\n"
		"std::string_view synonym) const Xapian::WritableDatabase::add_synonym\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to add a synonym for.\n"
		"\n"
		"synonym:  The synonym to add. If this is already a synonym for term,\n"
		"then no action is taken. \n"
		""},
	 { "WritableDatabase_remove_synonym", _wrap_WritableDatabase_remove_synonym, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove a synonym for a term.\n"
		"\n"
		"void Xapian::WritableDatabase::remove_synonym(std::string_view term,\n"
		"std::string_view synonym) const\n"
		"Xapian::WritableDatabase::remove_synonym\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to remove a synonym for.\n"
		"\n"
		"synonym:  The synonym to remove. If this isn't currently a synonym for\n"
		"term, then no action is taken. \n"
		""},
	 { "WritableDatabase_clear_synonyms", _wrap_WritableDatabase_clear_synonyms, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Remove all synonyms for a term.\n"
		"\n"
		"void Xapian::WritableDatabase::clear_synonyms(std::string_view term)\n"
		"const Xapian::WritableDatabase::clear_synonyms\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"term:  The term to remove all synonyms for. If the term has no\n"
		"synonyms, no action is taken. \n"
		""},
	 { "WritableDatabase_set_metadata", _wrap_WritableDatabase_set_metadata, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Set the user-specified metadata associated with a given key.\n"
		"\n"
		"void Xapian::WritableDatabase::set_metadata(std::string_view key,\n"
		"std::string_view metadata) Xapian::WritableDatabase::set_metadata This\n"
		"method sets the metadata value associated with a given key. If there\n"
		"is already a metadata value stored in the database with the same key,\n"
		"the old value is replaced. If you want to delete an existing item of\n"
		"metadata, just set its value to the empty string.\n"
		"\n"
		"User-specified metadata allows you to store arbitrary information in\n"
		"the form of (key, value) pairs.\n"
		"\n"
		"There's no hard limit on the number of metadata items, or the size of\n"
		"the metadata values. Metadata keys have a limited length, which depend\n"
		"on the backend. We recommend limiting them to 200 bytes. Empty keys\n"
		"are not valid, and specifying one will cause an exception.\n"
		"\n"
		"Metadata modifications are committed to disk in the same way as\n"
		"modifications to the documents in the database are: i.e.,\n"
		"modifications are atomic, and won't be committed to disk immediately\n"
		"(see commit() for more details). This allows metadata to be used to\n"
		"link databases with versioned external resources by storing the\n"
		"appropriate version number in a metadata item.\n"
		"\n"
		"You can also use the metadata to store arbitrary extra information\n"
		"associated with terms, documents, or postings by encoding the termname\n"
		"and/or document id into the metadata key.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"key:  The key of the metadata item to set.\n"
		"\n"
		"metadata:  The value of the metadata item to set.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"Xapian::DatabaseError:  will be thrown if a problem occurs while\n"
		"writing to the database.\n"
		"\n"
		"Xapian::DatabaseCorruptError:  will be thrown if the database is in a\n"
		"corrupt state.\n"
		"\n"
		"Xapian::InvalidArgumentError:  will be thrown if the key supplied is\n"
		"empty.\n"
		"\n"
		"Xapian::UnimplementedError:  will be thrown if the database backend in\n"
		"use doesn't support user- specified metadata. \n"
		""},
	 { "delete_WritableDatabase", _wrap_delete_WritableDatabase, METH_O, NULL},
	 { "WritableDatabase_swigregister", WritableDatabase_swigregister, METH_O, NULL},
	 { "WritableDatabase_swiginit", WritableDatabase_swiginit, METH_VARARGS, NULL},
	 { "remote_open", _wrap_remote_open, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a Database object for read-only access to a remote database\n"
		"accessed via a program.\n"
		"\n"
		"Database Xapian::Remote::open(std::string_view program,\n"
		"std::string_view args, unsigned timeout=10000) Xapian::Remote::open\n"
		"Access to the remote database is done by running an external program\n"
		"and communicating with it on stdin/stdout.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"program:  the external program to run.\n"
		"\n"
		"args:  space-separated list of arguments to pass to program.\n"
		"\n"
		"timeout:  timeout in milliseconds. If this timeout is exceeded for any\n"
		"individual operation on the remote database then\n"
		"Xapian::NetworkTimeoutError is thrown. A timeout of 0 means don't\n"
		"timeout. (Default is 10000ms, which is 10 seconds). \n"
		""},
	 { "remote_open_writable", _wrap_remote_open_writable, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Construct a WritableDatabase object for update access to a remote\n"
		"database accessed via a program.\n"
		"\n"
		"WritableDatabase Xapian::Remote::open_writable(std::string_view\n"
		"program, std::string_view args, unsigned timeout=0, int flags=0)\n"
		"Xapian::Remote::open_writable Access to the remote database is done by\n"
		"running an external program and communicating with it on stdin/stdout.\n"
		"\n"
		"Parameters:\n"
		"-----------\n"
		"\n"
		"program:  the external program to run.\n"
		"\n"
		"args:  space-separated list of arguments to pass to program.\n"
		"\n"
		"timeout:  timeout in milliseconds. If this timeout is exceeded for any\n"
		"individual operation on the remote database then\n"
		"Xapian::NetworkTimeoutError is thrown. (Default is 0, which means\n"
		"don't timeout).\n"
		"\n"
		"flags:   Xapian::DB_RETRY_LOCK or 0. \n"
		""},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_Xapian__TradWeightTo_p_Xapian__BM25Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::BM25Weight *)  ((Xapian::TradWeight *) x));
}
static void *_p_Xapian__WritableDatabaseTo_p_Xapian__Database(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Database *)  ((Xapian::WritableDatabase *) x));
}
static void *_p_Xapian__DatabaseClosedErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *)  ((Xapian::DatabaseClosedError *) x));
}
static void *_p_Xapian__DatabaseCorruptErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *)  ((Xapian::DatabaseCorruptError *) x));
}
static void *_p_Xapian__DatabaseCreateErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *)  ((Xapian::DatabaseCreateError *) x));
}
static void *_p_Xapian__DatabaseLockErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *)  ((Xapian::DatabaseLockError *) x));
}
static void *_p_Xapian__DatabaseModifiedErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *)  ((Xapian::DatabaseModifiedError *) x));
}
static void *_p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *) (Xapian::DatabaseOpeningError *) ((Xapian::DatabaseNotFoundError *) x));
}
static void *_p_Xapian__DatabaseOpeningErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *)  ((Xapian::DatabaseOpeningError *) x));
}
static void *_p_Xapian__DatabaseVersionErrorTo_p_Xapian__DatabaseError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseError *) (Xapian::DatabaseOpeningError *) ((Xapian::DatabaseVersionError *) x));
}
static void *_p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__DatabaseOpeningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseOpeningError *)  ((Xapian::DatabaseNotFoundError *) x));
}
static void *_p_Xapian__DatabaseVersionErrorTo_p_Xapian__DatabaseOpeningError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::DatabaseOpeningError *)  ((Xapian::DatabaseVersionError *) x));
}
static void *_p_Xapian__AssertionErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::LogicError *) ((Xapian::AssertionError *) x));
}
static void *_p_Xapian__DatabaseClosedErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *) ((Xapian::DatabaseClosedError *) x));
}
static void *_p_Xapian__DatabaseCorruptErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *) ((Xapian::DatabaseCorruptError *) x));
}
static void *_p_Xapian__DatabaseCreateErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *) ((Xapian::DatabaseCreateError *) x));
}
static void *_p_Xapian__DatabaseErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::DatabaseError *) x));
}
static void *_p_Xapian__DatabaseLockErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *) ((Xapian::DatabaseLockError *) x));
}
static void *_p_Xapian__DatabaseModifiedErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *) ((Xapian::DatabaseModifiedError *) x));
}
static void *_p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *)(Xapian::DatabaseOpeningError *) ((Xapian::DatabaseNotFoundError *) x));
}
static void *_p_Xapian__DatabaseOpeningErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *) ((Xapian::DatabaseOpeningError *) x));
}
static void *_p_Xapian__DatabaseVersionErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::DatabaseError *)(Xapian::DatabaseOpeningError *) ((Xapian::DatabaseVersionError *) x));
}
static void *_p_Xapian__DocNotFoundErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::DocNotFoundError *) x));
}
static void *_p_Xapian__FeatureUnavailableErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::FeatureUnavailableError *) x));
}
static void *_p_Xapian__InternalErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::InternalError *) x));
}
static void *_p_Xapian__InvalidArgumentErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::LogicError *) ((Xapian::InvalidArgumentError *) x));
}
static void *_p_Xapian__InvalidOperationErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::LogicError *) ((Xapian::InvalidOperationError *) x));
}
static void *_p_Xapian__LogicErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *)  ((Xapian::LogicError *) x));
}
static void *_p_Xapian__NetworkErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::NetworkError *) x));
}
static void *_p_Xapian__NetworkTimeoutErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *)(Xapian::NetworkError *) ((Xapian::NetworkTimeoutError *) x));
}
static void *_p_Xapian__QueryParserErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::QueryParserError *) x));
}
static void *_p_Xapian__RangeErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::RangeError *) x));
}
static void *_p_Xapian__RuntimeErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *)  ((Xapian::RuntimeError *) x));
}
static void *_p_Xapian__SerialisationErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::SerialisationError *) x));
}
static void *_p_Xapian__UnimplementedErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::LogicError *) ((Xapian::UnimplementedError *) x));
}
static void *_p_Xapian__WildcardErrorTo_p_Xapian__Error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Error *) (Xapian::RuntimeError *) ((Xapian::WildcardError *) x));
}
static void *_p_Xapian__ExpandDeciderAndTo_p_Xapian__ExpandDecider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ExpandDecider *)  ((Xapian::ExpandDeciderAnd *) x));
}
static void *_p_Xapian__ExpandDeciderFilterPrefixTo_p_Xapian__ExpandDecider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ExpandDecider *)  ((Xapian::ExpandDeciderFilterPrefix *) x));
}
static void *_p_Xapian__ExpandDeciderFilterTermsTo_p_Xapian__ExpandDecider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ExpandDecider *)  ((Xapian::ExpandDeciderFilterTerms *) x));
}
static void *_p_Xapian__LatLongDistanceKeyMakerTo_p_Xapian__KeyMaker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::KeyMaker *)  ((Xapian::LatLongDistanceKeyMaker *) x));
}
static void *_p_Xapian__MultiValueKeyMakerTo_p_Xapian__KeyMaker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::KeyMaker *)  ((Xapian::MultiValueKeyMaker *) x));
}
static void *_p_Xapian__GreatCircleMetricTo_p_Xapian__LatLongMetric(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::LatLongMetric *)  ((Xapian::GreatCircleMetric *) x));
}
static void *_p_Xapian__AssertionErrorTo_p_Xapian__LogicError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::LogicError *)  ((Xapian::AssertionError *) x));
}
static void *_p_Xapian__InvalidArgumentErrorTo_p_Xapian__LogicError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::LogicError *)  ((Xapian::InvalidArgumentError *) x));
}
static void *_p_Xapian__InvalidOperationErrorTo_p_Xapian__LogicError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::LogicError *)  ((Xapian::InvalidOperationError *) x));
}
static void *_p_Xapian__UnimplementedErrorTo_p_Xapian__LogicError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::LogicError *)  ((Xapian::UnimplementedError *) x));
}
static void *_p_Xapian__ValueSetMatchDeciderTo_p_Xapian__MatchDecider(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::MatchDecider *)  ((Xapian::ValueSetMatchDecider *) x));
}
static void *_p_Xapian__ValueCountMatchSpyTo_p_Xapian__MatchSpy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::MatchSpy *)  ((Xapian::ValueCountMatchSpy *) x));
}
static void *_p_Xapian__NetworkTimeoutErrorTo_p_Xapian__NetworkError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::NetworkError *)  ((Xapian::NetworkTimeoutError *) x));
}
static void *_p_Xapian__DecreasingValueWeightPostingSourceTo_p_Xapian__PostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::PostingSource *) (Xapian::ValuePostingSource *)(Xapian::ValueWeightPostingSource *) ((Xapian::DecreasingValueWeightPostingSource *) x));
}
static void *_p_Xapian__FixedWeightPostingSourceTo_p_Xapian__PostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::PostingSource *)  ((Xapian::FixedWeightPostingSource *) x));
}
static void *_p_Xapian__LatLongDistancePostingSourceTo_p_Xapian__PostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::PostingSource *) (Xapian::ValuePostingSource *) ((Xapian::LatLongDistancePostingSource *) x));
}
static void *_p_Xapian__ValueMapPostingSourceTo_p_Xapian__PostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::PostingSource *) (Xapian::ValuePostingSource *) ((Xapian::ValueMapPostingSource *) x));
}
static void *_p_Xapian__ValuePostingSourceTo_p_Xapian__PostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::PostingSource *)  ((Xapian::ValuePostingSource *) x));
}
static void *_p_Xapian__ValueWeightPostingSourceTo_p_Xapian__PostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::PostingSource *) (Xapian::ValuePostingSource *) ((Xapian::ValueWeightPostingSource *) x));
}
static void *_p_Xapian__DateRangeProcessorTo_p_Xapian__RangeProcessor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RangeProcessor *)  ((Xapian::DateRangeProcessor *) x));
}
static void *_p_Xapian__NumberRangeProcessorTo_p_Xapian__RangeProcessor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RangeProcessor *)  ((Xapian::NumberRangeProcessor *) x));
}
static void *_p_Xapian__UnitRangeProcessorTo_p_Xapian__RangeProcessor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RangeProcessor *)  ((Xapian::UnitRangeProcessor *) x));
}
static void *_p_Xapian__DatabaseClosedErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *) ((Xapian::DatabaseClosedError *) x));
}
static void *_p_Xapian__DatabaseCorruptErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *) ((Xapian::DatabaseCorruptError *) x));
}
static void *_p_Xapian__DatabaseCreateErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *) ((Xapian::DatabaseCreateError *) x));
}
static void *_p_Xapian__DatabaseErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::DatabaseError *) x));
}
static void *_p_Xapian__DatabaseLockErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *) ((Xapian::DatabaseLockError *) x));
}
static void *_p_Xapian__DatabaseModifiedErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *) ((Xapian::DatabaseModifiedError *) x));
}
static void *_p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *)(Xapian::DatabaseOpeningError *) ((Xapian::DatabaseNotFoundError *) x));
}
static void *_p_Xapian__DatabaseOpeningErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *) ((Xapian::DatabaseOpeningError *) x));
}
static void *_p_Xapian__DatabaseVersionErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::DatabaseError *)(Xapian::DatabaseOpeningError *) ((Xapian::DatabaseVersionError *) x));
}
static void *_p_Xapian__DocNotFoundErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::DocNotFoundError *) x));
}
static void *_p_Xapian__FeatureUnavailableErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::FeatureUnavailableError *) x));
}
static void *_p_Xapian__InternalErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::InternalError *) x));
}
static void *_p_Xapian__NetworkErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::NetworkError *) x));
}
static void *_p_Xapian__NetworkTimeoutErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *) (Xapian::NetworkError *) ((Xapian::NetworkTimeoutError *) x));
}
static void *_p_Xapian__QueryParserErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::QueryParserError *) x));
}
static void *_p_Xapian__RangeErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::RangeError *) x));
}
static void *_p_Xapian__SerialisationErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::SerialisationError *) x));
}
static void *_p_Xapian__WildcardErrorTo_p_Xapian__RuntimeError(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::RuntimeError *)  ((Xapian::WildcardError *) x));
}
static void *_p_Xapian__SimpleStopperTo_p_Xapian__Stopper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Stopper *)  ((Xapian::SimpleStopper *) x));
}
static void *_p_Xapian__DecreasingValueWeightPostingSourceTo_p_Xapian__ValuePostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ValuePostingSource *) (Xapian::ValueWeightPostingSource *) ((Xapian::DecreasingValueWeightPostingSource *) x));
}
static void *_p_Xapian__LatLongDistancePostingSourceTo_p_Xapian__ValuePostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ValuePostingSource *)  ((Xapian::LatLongDistancePostingSource *) x));
}
static void *_p_Xapian__ValueMapPostingSourceTo_p_Xapian__ValuePostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ValuePostingSource *)  ((Xapian::ValueMapPostingSource *) x));
}
static void *_p_Xapian__ValueWeightPostingSourceTo_p_Xapian__ValuePostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ValuePostingSource *)  ((Xapian::ValueWeightPostingSource *) x));
}
static void *_p_Xapian__DecreasingValueWeightPostingSourceTo_p_Xapian__ValueWeightPostingSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::ValueWeightPostingSource *)  ((Xapian::DecreasingValueWeightPostingSource *) x));
}
static void *_p_Xapian__BB2WeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::BB2Weight *) x));
}
static void *_p_Xapian__BM25PlusWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::BM25PlusWeight *) x));
}
static void *_p_Xapian__BM25WeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::BM25Weight *) x));
}
static void *_p_Xapian__BoolWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::BoolWeight *) x));
}
static void *_p_Xapian__CoordWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::CoordWeight *) x));
}
static void *_p_Xapian__DLHWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::DLHWeight *) x));
}
static void *_p_Xapian__DPHWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::DPHWeight *) x));
}
static void *_p_Xapian__DiceWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::DiceWeight *) x));
}
static void *_p_Xapian__IfB2WeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::IfB2Weight *) x));
}
static void *_p_Xapian__InL2WeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::InL2Weight *) x));
}
static void *_p_Xapian__IneB2WeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::IneB2Weight *) x));
}
static void *_p_Xapian__LM2StageWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::LM2StageWeight *) x));
}
static void *_p_Xapian__LMAbsDiscountWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::LMAbsDiscountWeight *) x));
}
static void *_p_Xapian__LMDirichletWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::LMDirichletWeight *) x));
}
static void *_p_Xapian__LMJMWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::LMJMWeight *) x));
}
static void *_p_Xapian__PL2PlusWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::PL2PlusWeight *) x));
}
static void *_p_Xapian__PL2WeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::PL2Weight *) x));
}
static void *_p_Xapian__TfIdfWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *)  ((Xapian::TfIdfWeight *) x));
}
static void *_p_Xapian__TradWeightTo_p_Xapian__Weight(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Xapian::Weight *) (Xapian::BM25Weight *) ((Xapian::TradWeight *) x));
}
static swig_type_info _swigt__p_Xapian__AssertionError = {"_p_Xapian__AssertionError", "Xapian::AssertionError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__BB2Weight = {"_p_Xapian__BB2Weight", "Xapian::BB2Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__BM25PlusWeight = {"_p_Xapian__BM25PlusWeight", "Xapian::BM25PlusWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__BM25Weight = {"_p_Xapian__BM25Weight", "Xapian::BM25Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__BoolWeight = {"_p_Xapian__BoolWeight", "Xapian::BoolWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Compactor = {"_p_Xapian__Compactor", "Xapian::Compactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__CoordWeight = {"_p_Xapian__CoordWeight", "Xapian::CoordWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DLHWeight = {"_p_Xapian__DLHWeight", "Xapian::DLHWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DPHWeight = {"_p_Xapian__DPHWeight", "Xapian::DPHWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Database = {"_p_Xapian__Database", "Xapian::Database *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseClosedError = {"_p_Xapian__DatabaseClosedError", "Xapian::DatabaseClosedError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseCorruptError = {"_p_Xapian__DatabaseCorruptError", "Xapian::DatabaseCorruptError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseCreateError = {"_p_Xapian__DatabaseCreateError", "Xapian::DatabaseCreateError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseError = {"_p_Xapian__DatabaseError", "Xapian::DatabaseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseLockError = {"_p_Xapian__DatabaseLockError", "Xapian::DatabaseLockError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseModifiedError = {"_p_Xapian__DatabaseModifiedError", "Xapian::DatabaseModifiedError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseNotFoundError = {"_p_Xapian__DatabaseNotFoundError", "Xapian::DatabaseNotFoundError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseOpeningError = {"_p_Xapian__DatabaseOpeningError", "Xapian::DatabaseOpeningError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DatabaseVersionError = {"_p_Xapian__DatabaseVersionError", "Xapian::DatabaseVersionError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DateRangeProcessor = {"_p_Xapian__DateRangeProcessor", "Xapian::DateRangeProcessor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DecreasingValueWeightPostingSource = {"_p_Xapian__DecreasingValueWeightPostingSource", "Xapian::DecreasingValueWeightPostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DiceWeight = {"_p_Xapian__DiceWeight", "Xapian::DiceWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__DocNotFoundError = {"_p_Xapian__DocNotFoundError", "Xapian::DocNotFoundError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Document = {"_p_Xapian__Document", "Xapian::Document *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ESet = {"_p_Xapian__ESet", "Xapian::ESet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ESetIterator = {"_p_Xapian__ESetIterator", "Xapian::ESetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Enquire = {"_p_Xapian__Enquire", "Xapian::Enquire *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Error = {"_p_Xapian__Error", "Xapian::Error *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ExpandDecider = {"_p_Xapian__ExpandDecider", "Xapian::ExpandDecider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ExpandDeciderFilterTerms = {"_p_Xapian__ExpandDeciderFilterTerms", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_Xapian__ExpandDeciderAnd = {"_p_Xapian__ExpandDeciderAnd", "Xapian::ExpandDeciderAnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ExpandDeciderFilterPrefix = {"_p_Xapian__ExpandDeciderFilterPrefix", "Xapian::ExpandDeciderFilterPrefix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__FeatureUnavailableError = {"_p_Xapian__FeatureUnavailableError", "Xapian::FeatureUnavailableError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__FieldProcessor = {"_p_Xapian__FieldProcessor", "Xapian::FieldProcessor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__FixedWeightPostingSource = {"_p_Xapian__FixedWeightPostingSource", "Xapian::FixedWeightPostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__GreatCircleMetric = {"_p_Xapian__GreatCircleMetric", "Xapian::GreatCircleMetric *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__IfB2Weight = {"_p_Xapian__IfB2Weight", "Xapian::IfB2Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__InL2Weight = {"_p_Xapian__InL2Weight", "Xapian::InL2Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__IneB2Weight = {"_p_Xapian__IneB2Weight", "Xapian::IneB2Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__InternalError = {"_p_Xapian__InternalError", "Xapian::InternalError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__InvalidArgumentError = {"_p_Xapian__InvalidArgumentError", "Xapian::InvalidArgumentError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__InvalidOperationError = {"_p_Xapian__InvalidOperationError", "Xapian::InvalidOperationError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__KeyMaker = {"_p_Xapian__KeyMaker", "Xapian::KeyMaker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LM2StageWeight = {"_p_Xapian__LM2StageWeight", "Xapian::LM2StageWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LMAbsDiscountWeight = {"_p_Xapian__LMAbsDiscountWeight", "Xapian::LMAbsDiscountWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LMDirichletWeight = {"_p_Xapian__LMDirichletWeight", "Xapian::LMDirichletWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LMJMWeight = {"_p_Xapian__LMJMWeight", "Xapian::LMJMWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LatLongCoord = {"_p_Xapian__LatLongCoord", "Xapian::LatLongCoord *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LatLongCoords = {"_p_Xapian__LatLongCoords", "Xapian::LatLongCoords *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LatLongCoordsIterator = {"_p_Xapian__LatLongCoordsIterator", "Xapian::LatLongCoordsIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LatLongDistanceKeyMaker = {"_p_Xapian__LatLongDistanceKeyMaker", "Xapian::LatLongDistanceKeyMaker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LatLongDistancePostingSource = {"_p_Xapian__LatLongDistancePostingSource", "Xapian::LatLongDistancePostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LatLongMetric = {"_p_Xapian__LatLongMetric", "Xapian::LatLongMetric *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__LogicError = {"_p_Xapian__LogicError", "Xapian::LogicError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__MSet = {"_p_Xapian__MSet", "Xapian::MSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__MSetIterator = {"_p_Xapian__MSetIterator", "Xapian::MSetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__MatchDecider = {"_p_Xapian__MatchDecider", "Xapian::MatchDecider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__MatchSpy = {"_p_Xapian__MatchSpy", "Xapian::MatchSpy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__MultiValueKeyMaker = {"_p_Xapian__MultiValueKeyMaker", "Xapian::MultiValueKeyMaker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__NetworkError = {"_p_Xapian__NetworkError", "Xapian::NetworkError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__NetworkTimeoutError = {"_p_Xapian__NetworkTimeoutError", "Xapian::NetworkTimeoutError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__NumberRangeProcessor = {"_p_Xapian__NumberRangeProcessor", "Xapian::NumberRangeProcessor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__PL2PlusWeight = {"_p_Xapian__PL2PlusWeight", "Xapian::PL2PlusWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__PL2Weight = {"_p_Xapian__PL2Weight", "Xapian::PL2Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__PositionIterator = {"_p_Xapian__PositionIterator", "Xapian::PositionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__PostingIterator = {"_p_Xapian__PostingIterator", "Xapian::PostingIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__PostingSource = {"_p_Xapian__PostingSource", "Xapian::PostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Query = {"_p_Xapian__Query", "Xapian::Query *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__QueryParser = {"_p_Xapian__QueryParser", "Xapian::QueryParser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__QueryParserError = {"_p_Xapian__QueryParserError", "Xapian::QueryParserError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__RSet = {"_p_Xapian__RSet", "Xapian::RSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__RangeError = {"_p_Xapian__RangeError", "Xapian::RangeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__RangeProcessor = {"_p_Xapian__RangeProcessor", "Xapian::RangeProcessor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Registry = {"_p_Xapian__Registry", "Xapian::Registry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__RuntimeError = {"_p_Xapian__RuntimeError", "Xapian::RuntimeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__SerialisationError = {"_p_Xapian__SerialisationError", "Xapian::SerialisationError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__SimpleStopper = {"_p_Xapian__SimpleStopper", "Xapian::SimpleStopper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Stem = {"_p_Xapian__Stem", "Xapian::Stem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__StemImplementation = {"_p_Xapian__StemImplementation", "Xapian::StemImplementation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Stopper = {"_p_Xapian__Stopper", "Xapian::Stopper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__TermGenerator = {"_p_Xapian__TermGenerator", "Xapian::TermGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__TermIterator = {"_p_Xapian__TermIterator", "Xapian::TermIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__TfIdfWeight = {"_p_Xapian__TfIdfWeight", "Xapian::TfIdfWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__TradWeight = {"_p_Xapian__TradWeight", "Xapian::TradWeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__UnimplementedError = {"_p_Xapian__UnimplementedError", "Xapian::UnimplementedError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__UnitRangeProcessor = {"_p_Xapian__UnitRangeProcessor", "Xapian::UnitRangeProcessor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ValueCountMatchSpy = {"_p_Xapian__ValueCountMatchSpy", "Xapian::ValueCountMatchSpy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ValueIterator = {"_p_Xapian__ValueIterator", "Xapian::ValueIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ValueMapPostingSource = {"_p_Xapian__ValueMapPostingSource", "Xapian::ValueMapPostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ValuePostingSource = {"_p_Xapian__ValuePostingSource", "Xapian::ValuePostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ValueSetMatchDecider = {"_p_Xapian__ValueSetMatchDecider", "Xapian::ValueSetMatchDecider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__ValueWeightPostingSource = {"_p_Xapian__ValueWeightPostingSource", "Xapian::ValueWeightPostingSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__Weight = {"_p_Xapian__Weight", "Xapian::Weight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__WildcardError = {"_p_Xapian__WildcardError", "Xapian::WildcardError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Xapian__WritableDatabase = {"_p_Xapian__WritableDatabase", "Xapian::WritableDatabase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_compaction_level = {"_p_compaction_level", "compaction_level *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_docid_order = {"_p_docid_order", "docid_order *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "Xapian::doclength *|double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_feature_flag = {"_p_feature_flag", "feature_flag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_flags = {"_p_flags", "flags *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "Xapian::doccount_diff *|Xapian::termcount_diff *|Xapian::termpos_diff *|Xapian::valueno_diff *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_stem_strategy = {"_p_stem_strategy", "stem_strategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_stop_strategy = {"_p_stop_strategy", "stop_strategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "Xapian::doccount *|Xapian::docid *|Xapian::termcount *|Xapian::termpos *|Xapian::valueno *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Xapian::rev *|Xapian::totallength *|unsigned long *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_Xapian__AssertionError,
  &_swigt__p_Xapian__BB2Weight,
  &_swigt__p_Xapian__BM25PlusWeight,
  &_swigt__p_Xapian__BM25Weight,
  &_swigt__p_Xapian__BoolWeight,
  &_swigt__p_Xapian__Compactor,
  &_swigt__p_Xapian__CoordWeight,
  &_swigt__p_Xapian__DLHWeight,
  &_swigt__p_Xapian__DPHWeight,
  &_swigt__p_Xapian__Database,
  &_swigt__p_Xapian__DatabaseClosedError,
  &_swigt__p_Xapian__DatabaseCorruptError,
  &_swigt__p_Xapian__DatabaseCreateError,
  &_swigt__p_Xapian__DatabaseError,
  &_swigt__p_Xapian__DatabaseLockError,
  &_swigt__p_Xapian__DatabaseModifiedError,
  &_swigt__p_Xapian__DatabaseNotFoundError,
  &_swigt__p_Xapian__DatabaseOpeningError,
  &_swigt__p_Xapian__DatabaseVersionError,
  &_swigt__p_Xapian__DateRangeProcessor,
  &_swigt__p_Xapian__DecreasingValueWeightPostingSource,
  &_swigt__p_Xapian__DiceWeight,
  &_swigt__p_Xapian__DocNotFoundError,
  &_swigt__p_Xapian__Document,
  &_swigt__p_Xapian__ESet,
  &_swigt__p_Xapian__ESetIterator,
  &_swigt__p_Xapian__Enquire,
  &_swigt__p_Xapian__Error,
  &_swigt__p_Xapian__ExpandDecider,
  &_swigt__p_Xapian__ExpandDeciderAnd,
  &_swigt__p_Xapian__ExpandDeciderFilterPrefix,
  &_swigt__p_Xapian__ExpandDeciderFilterTerms,
  &_swigt__p_Xapian__FeatureUnavailableError,
  &_swigt__p_Xapian__FieldProcessor,
  &_swigt__p_Xapian__FixedWeightPostingSource,
  &_swigt__p_Xapian__GreatCircleMetric,
  &_swigt__p_Xapian__IfB2Weight,
  &_swigt__p_Xapian__InL2Weight,
  &_swigt__p_Xapian__IneB2Weight,
  &_swigt__p_Xapian__InternalError,
  &_swigt__p_Xapian__InvalidArgumentError,
  &_swigt__p_Xapian__InvalidOperationError,
  &_swigt__p_Xapian__KeyMaker,
  &_swigt__p_Xapian__LM2StageWeight,
  &_swigt__p_Xapian__LMAbsDiscountWeight,
  &_swigt__p_Xapian__LMDirichletWeight,
  &_swigt__p_Xapian__LMJMWeight,
  &_swigt__p_Xapian__LatLongCoord,
  &_swigt__p_Xapian__LatLongCoords,
  &_swigt__p_Xapian__LatLongCoordsIterator,
  &_swigt__p_Xapian__LatLongDistanceKeyMaker,
  &_swigt__p_Xapian__LatLongDistancePostingSource,
  &_swigt__p_Xapian__LatLongMetric,
  &_swigt__p_Xapian__LogicError,
  &_swigt__p_Xapian__MSet,
  &_swigt__p_Xapian__MSetIterator,
  &_swigt__p_Xapian__MatchDecider,
  &_swigt__p_Xapian__MatchSpy,
  &_swigt__p_Xapian__MultiValueKeyMaker,
  &_swigt__p_Xapian__NetworkError,
  &_swigt__p_Xapian__NetworkTimeoutError,
  &_swigt__p_Xapian__NumberRangeProcessor,
  &_swigt__p_Xapian__PL2PlusWeight,
  &_swigt__p_Xapian__PL2Weight,
  &_swigt__p_Xapian__PositionIterator,
  &_swigt__p_Xapian__PostingIterator,
  &_swigt__p_Xapian__PostingSource,
  &_swigt__p_Xapian__Query,
  &_swigt__p_Xapian__QueryParser,
  &_swigt__p_Xapian__QueryParserError,
  &_swigt__p_Xapian__RSet,
  &_swigt__p_Xapian__RangeError,
  &_swigt__p_Xapian__RangeProcessor,
  &_swigt__p_Xapian__Registry,
  &_swigt__p_Xapian__RuntimeError,
  &_swigt__p_Xapian__SerialisationError,
  &_swigt__p_Xapian__SimpleStopper,
  &_swigt__p_Xapian__Stem,
  &_swigt__p_Xapian__StemImplementation,
  &_swigt__p_Xapian__Stopper,
  &_swigt__p_Xapian__TermGenerator,
  &_swigt__p_Xapian__TermIterator,
  &_swigt__p_Xapian__TfIdfWeight,
  &_swigt__p_Xapian__TradWeight,
  &_swigt__p_Xapian__UnimplementedError,
  &_swigt__p_Xapian__UnitRangeProcessor,
  &_swigt__p_Xapian__ValueCountMatchSpy,
  &_swigt__p_Xapian__ValueIterator,
  &_swigt__p_Xapian__ValueMapPostingSource,
  &_swigt__p_Xapian__ValuePostingSource,
  &_swigt__p_Xapian__ValueSetMatchDecider,
  &_swigt__p_Xapian__ValueWeightPostingSource,
  &_swigt__p_Xapian__Weight,
  &_swigt__p_Xapian__WildcardError,
  &_swigt__p_Xapian__WritableDatabase,
  &_swigt__p_char,
  &_swigt__p_compaction_level,
  &_swigt__p_const_reference,
  &_swigt__p_docid_order,
  &_swigt__p_double,
  &_swigt__p_feature_flag,
  &_swigt__p_flags,
  &_swigt__p_int,
  &_swigt__p_reference,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__string,
  &_swigt__p_stem_strategy,
  &_swigt__p_stop_strategy,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
};

static swig_cast_info _swigc__p_Xapian__AssertionError[] = {  {&_swigt__p_Xapian__AssertionError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__BB2Weight[] = {  {&_swigt__p_Xapian__BB2Weight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__BM25PlusWeight[] = {  {&_swigt__p_Xapian__BM25PlusWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__BM25Weight[] = {  {&_swigt__p_Xapian__BM25Weight, 0, 0, 0},  {&_swigt__p_Xapian__TradWeight, _p_Xapian__TradWeightTo_p_Xapian__BM25Weight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__BoolWeight[] = {  {&_swigt__p_Xapian__BoolWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Compactor[] = {  {&_swigt__p_Xapian__Compactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__CoordWeight[] = {  {&_swigt__p_Xapian__CoordWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DLHWeight[] = {  {&_swigt__p_Xapian__DLHWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DPHWeight[] = {  {&_swigt__p_Xapian__DPHWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Database[] = {  {&_swigt__p_Xapian__Database, 0, 0, 0},  {&_swigt__p_Xapian__WritableDatabase, _p_Xapian__WritableDatabaseTo_p_Xapian__Database, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseClosedError[] = {  {&_swigt__p_Xapian__DatabaseClosedError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseCorruptError[] = {  {&_swigt__p_Xapian__DatabaseCorruptError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseCreateError[] = {  {&_swigt__p_Xapian__DatabaseCreateError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseError[] = {  {&_swigt__p_Xapian__DatabaseError, 0, 0, 0},  {&_swigt__p_Xapian__DatabaseClosedError, _p_Xapian__DatabaseClosedErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseCorruptError, _p_Xapian__DatabaseCorruptErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseCreateError, _p_Xapian__DatabaseCreateErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseLockError, _p_Xapian__DatabaseLockErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseModifiedError, _p_Xapian__DatabaseModifiedErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseNotFoundError, _p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseOpeningError, _p_Xapian__DatabaseOpeningErrorTo_p_Xapian__DatabaseError, 0, 0},  {&_swigt__p_Xapian__DatabaseVersionError, _p_Xapian__DatabaseVersionErrorTo_p_Xapian__DatabaseError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseLockError[] = {  {&_swigt__p_Xapian__DatabaseLockError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseModifiedError[] = {  {&_swigt__p_Xapian__DatabaseModifiedError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseNotFoundError[] = {  {&_swigt__p_Xapian__DatabaseNotFoundError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseOpeningError[] = {  {&_swigt__p_Xapian__DatabaseOpeningError, 0, 0, 0},  {&_swigt__p_Xapian__DatabaseNotFoundError, _p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__DatabaseOpeningError, 0, 0},  {&_swigt__p_Xapian__DatabaseVersionError, _p_Xapian__DatabaseVersionErrorTo_p_Xapian__DatabaseOpeningError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DatabaseVersionError[] = {  {&_swigt__p_Xapian__DatabaseVersionError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DateRangeProcessor[] = {  {&_swigt__p_Xapian__DateRangeProcessor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DecreasingValueWeightPostingSource[] = {  {&_swigt__p_Xapian__DecreasingValueWeightPostingSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DiceWeight[] = {  {&_swigt__p_Xapian__DiceWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__DocNotFoundError[] = {  {&_swigt__p_Xapian__DocNotFoundError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Document[] = {  {&_swigt__p_Xapian__Document, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ESet[] = {  {&_swigt__p_Xapian__ESet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ESetIterator[] = {  {&_swigt__p_Xapian__ESetIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Enquire[] = {  {&_swigt__p_Xapian__Enquire, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Error[] = {  {&_swigt__p_Xapian__Error, 0, 0, 0},  {&_swigt__p_Xapian__AssertionError, _p_Xapian__AssertionErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseClosedError, _p_Xapian__DatabaseClosedErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseCorruptError, _p_Xapian__DatabaseCorruptErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseCreateError, _p_Xapian__DatabaseCreateErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseError, _p_Xapian__DatabaseErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseLockError, _p_Xapian__DatabaseLockErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseModifiedError, _p_Xapian__DatabaseModifiedErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseNotFoundError, _p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseOpeningError, _p_Xapian__DatabaseOpeningErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DatabaseVersionError, _p_Xapian__DatabaseVersionErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__DocNotFoundError, _p_Xapian__DocNotFoundErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__FeatureUnavailableError, _p_Xapian__FeatureUnavailableErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__InternalError, _p_Xapian__InternalErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__InvalidArgumentError, _p_Xapian__InvalidArgumentErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__InvalidOperationError, _p_Xapian__InvalidOperationErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__LogicError, _p_Xapian__LogicErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__NetworkError, _p_Xapian__NetworkErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__NetworkTimeoutError, _p_Xapian__NetworkTimeoutErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__QueryParserError, _p_Xapian__QueryParserErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__RangeError, _p_Xapian__RangeErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__RuntimeError, _p_Xapian__RuntimeErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__SerialisationError, _p_Xapian__SerialisationErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__UnimplementedError, _p_Xapian__UnimplementedErrorTo_p_Xapian__Error, 0, 0},  {&_swigt__p_Xapian__WildcardError, _p_Xapian__WildcardErrorTo_p_Xapian__Error, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ExpandDeciderFilterTerms[] = {{&_swigt__p_Xapian__ExpandDeciderFilterTerms, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ExpandDecider[] = {  {&_swigt__p_Xapian__ExpandDecider, 0, 0, 0},  {&_swigt__p_Xapian__ExpandDeciderAnd, _p_Xapian__ExpandDeciderAndTo_p_Xapian__ExpandDecider, 0, 0},  {&_swigt__p_Xapian__ExpandDeciderFilterPrefix, _p_Xapian__ExpandDeciderFilterPrefixTo_p_Xapian__ExpandDecider, 0, 0},  {&_swigt__p_Xapian__ExpandDeciderFilterTerms, _p_Xapian__ExpandDeciderFilterTermsTo_p_Xapian__ExpandDecider, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ExpandDeciderAnd[] = {  {&_swigt__p_Xapian__ExpandDeciderAnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ExpandDeciderFilterPrefix[] = {  {&_swigt__p_Xapian__ExpandDeciderFilterPrefix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__FeatureUnavailableError[] = {  {&_swigt__p_Xapian__FeatureUnavailableError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__FieldProcessor[] = {  {&_swigt__p_Xapian__FieldProcessor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__FixedWeightPostingSource[] = {  {&_swigt__p_Xapian__FixedWeightPostingSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__GreatCircleMetric[] = {  {&_swigt__p_Xapian__GreatCircleMetric, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__IfB2Weight[] = {  {&_swigt__p_Xapian__IfB2Weight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__InL2Weight[] = {  {&_swigt__p_Xapian__InL2Weight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__IneB2Weight[] = {  {&_swigt__p_Xapian__IneB2Weight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__InternalError[] = {  {&_swigt__p_Xapian__InternalError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__InvalidArgumentError[] = {  {&_swigt__p_Xapian__InvalidArgumentError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__InvalidOperationError[] = {  {&_swigt__p_Xapian__InvalidOperationError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__KeyMaker[] = {  {&_swigt__p_Xapian__KeyMaker, 0, 0, 0},  {&_swigt__p_Xapian__LatLongDistanceKeyMaker, _p_Xapian__LatLongDistanceKeyMakerTo_p_Xapian__KeyMaker, 0, 0},  {&_swigt__p_Xapian__MultiValueKeyMaker, _p_Xapian__MultiValueKeyMakerTo_p_Xapian__KeyMaker, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LM2StageWeight[] = {  {&_swigt__p_Xapian__LM2StageWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LMAbsDiscountWeight[] = {  {&_swigt__p_Xapian__LMAbsDiscountWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LMDirichletWeight[] = {  {&_swigt__p_Xapian__LMDirichletWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LMJMWeight[] = {  {&_swigt__p_Xapian__LMJMWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LatLongCoord[] = {  {&_swigt__p_Xapian__LatLongCoord, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LatLongCoords[] = {  {&_swigt__p_Xapian__LatLongCoords, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LatLongCoordsIterator[] = {  {&_swigt__p_Xapian__LatLongCoordsIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LatLongDistanceKeyMaker[] = {  {&_swigt__p_Xapian__LatLongDistanceKeyMaker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LatLongDistancePostingSource[] = {  {&_swigt__p_Xapian__LatLongDistancePostingSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LatLongMetric[] = {  {&_swigt__p_Xapian__LatLongMetric, 0, 0, 0},  {&_swigt__p_Xapian__GreatCircleMetric, _p_Xapian__GreatCircleMetricTo_p_Xapian__LatLongMetric, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__LogicError[] = {  {&_swigt__p_Xapian__LogicError, 0, 0, 0},  {&_swigt__p_Xapian__AssertionError, _p_Xapian__AssertionErrorTo_p_Xapian__LogicError, 0, 0},  {&_swigt__p_Xapian__InvalidArgumentError, _p_Xapian__InvalidArgumentErrorTo_p_Xapian__LogicError, 0, 0},  {&_swigt__p_Xapian__InvalidOperationError, _p_Xapian__InvalidOperationErrorTo_p_Xapian__LogicError, 0, 0},  {&_swigt__p_Xapian__UnimplementedError, _p_Xapian__UnimplementedErrorTo_p_Xapian__LogicError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__MSet[] = {  {&_swigt__p_Xapian__MSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__MSetIterator[] = {  {&_swigt__p_Xapian__MSetIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__MatchDecider[] = {  {&_swigt__p_Xapian__MatchDecider, 0, 0, 0},  {&_swigt__p_Xapian__ValueSetMatchDecider, _p_Xapian__ValueSetMatchDeciderTo_p_Xapian__MatchDecider, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__MatchSpy[] = {  {&_swigt__p_Xapian__MatchSpy, 0, 0, 0},  {&_swigt__p_Xapian__ValueCountMatchSpy, _p_Xapian__ValueCountMatchSpyTo_p_Xapian__MatchSpy, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__MultiValueKeyMaker[] = {  {&_swigt__p_Xapian__MultiValueKeyMaker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__NetworkError[] = {  {&_swigt__p_Xapian__NetworkError, 0, 0, 0},  {&_swigt__p_Xapian__NetworkTimeoutError, _p_Xapian__NetworkTimeoutErrorTo_p_Xapian__NetworkError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__NetworkTimeoutError[] = {  {&_swigt__p_Xapian__NetworkTimeoutError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__NumberRangeProcessor[] = {  {&_swigt__p_Xapian__NumberRangeProcessor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__PL2PlusWeight[] = {  {&_swigt__p_Xapian__PL2PlusWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__PL2Weight[] = {  {&_swigt__p_Xapian__PL2Weight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__PositionIterator[] = {  {&_swigt__p_Xapian__PositionIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__PostingIterator[] = {  {&_swigt__p_Xapian__PostingIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__PostingSource[] = {  {&_swigt__p_Xapian__PostingSource, 0, 0, 0},  {&_swigt__p_Xapian__DecreasingValueWeightPostingSource, _p_Xapian__DecreasingValueWeightPostingSourceTo_p_Xapian__PostingSource, 0, 0},  {&_swigt__p_Xapian__FixedWeightPostingSource, _p_Xapian__FixedWeightPostingSourceTo_p_Xapian__PostingSource, 0, 0},  {&_swigt__p_Xapian__LatLongDistancePostingSource, _p_Xapian__LatLongDistancePostingSourceTo_p_Xapian__PostingSource, 0, 0},  {&_swigt__p_Xapian__ValueMapPostingSource, _p_Xapian__ValueMapPostingSourceTo_p_Xapian__PostingSource, 0, 0},  {&_swigt__p_Xapian__ValuePostingSource, _p_Xapian__ValuePostingSourceTo_p_Xapian__PostingSource, 0, 0},  {&_swigt__p_Xapian__ValueWeightPostingSource, _p_Xapian__ValueWeightPostingSourceTo_p_Xapian__PostingSource, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Query[] = {  {&_swigt__p_Xapian__Query, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__QueryParser[] = {  {&_swigt__p_Xapian__QueryParser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__QueryParserError[] = {  {&_swigt__p_Xapian__QueryParserError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__RSet[] = {  {&_swigt__p_Xapian__RSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__RangeError[] = {  {&_swigt__p_Xapian__RangeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__RangeProcessor[] = {  {&_swigt__p_Xapian__RangeProcessor, 0, 0, 0},  {&_swigt__p_Xapian__DateRangeProcessor, _p_Xapian__DateRangeProcessorTo_p_Xapian__RangeProcessor, 0, 0},  {&_swigt__p_Xapian__NumberRangeProcessor, _p_Xapian__NumberRangeProcessorTo_p_Xapian__RangeProcessor, 0, 0},  {&_swigt__p_Xapian__UnitRangeProcessor, _p_Xapian__UnitRangeProcessorTo_p_Xapian__RangeProcessor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Registry[] = {  {&_swigt__p_Xapian__Registry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__RuntimeError[] = {  {&_swigt__p_Xapian__RuntimeError, 0, 0, 0},  {&_swigt__p_Xapian__DatabaseClosedError, _p_Xapian__DatabaseClosedErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseCorruptError, _p_Xapian__DatabaseCorruptErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseCreateError, _p_Xapian__DatabaseCreateErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseError, _p_Xapian__DatabaseErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseLockError, _p_Xapian__DatabaseLockErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseModifiedError, _p_Xapian__DatabaseModifiedErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseNotFoundError, _p_Xapian__DatabaseNotFoundErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseOpeningError, _p_Xapian__DatabaseOpeningErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DatabaseVersionError, _p_Xapian__DatabaseVersionErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__DocNotFoundError, _p_Xapian__DocNotFoundErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__FeatureUnavailableError, _p_Xapian__FeatureUnavailableErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__InternalError, _p_Xapian__InternalErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__NetworkError, _p_Xapian__NetworkErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__NetworkTimeoutError, _p_Xapian__NetworkTimeoutErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__QueryParserError, _p_Xapian__QueryParserErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__RangeError, _p_Xapian__RangeErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__SerialisationError, _p_Xapian__SerialisationErrorTo_p_Xapian__RuntimeError, 0, 0},  {&_swigt__p_Xapian__WildcardError, _p_Xapian__WildcardErrorTo_p_Xapian__RuntimeError, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__SerialisationError[] = {  {&_swigt__p_Xapian__SerialisationError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__SimpleStopper[] = {  {&_swigt__p_Xapian__SimpleStopper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Stem[] = {  {&_swigt__p_Xapian__Stem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__StemImplementation[] = {  {&_swigt__p_Xapian__StemImplementation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Stopper[] = {  {&_swigt__p_Xapian__Stopper, 0, 0, 0},  {&_swigt__p_Xapian__SimpleStopper, _p_Xapian__SimpleStopperTo_p_Xapian__Stopper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__TermGenerator[] = {  {&_swigt__p_Xapian__TermGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__TermIterator[] = {  {&_swigt__p_Xapian__TermIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__TfIdfWeight[] = {  {&_swigt__p_Xapian__TfIdfWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__TradWeight[] = {  {&_swigt__p_Xapian__TradWeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__UnimplementedError[] = {  {&_swigt__p_Xapian__UnimplementedError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__UnitRangeProcessor[] = {  {&_swigt__p_Xapian__UnitRangeProcessor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ValueCountMatchSpy[] = {  {&_swigt__p_Xapian__ValueCountMatchSpy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ValueIterator[] = {  {&_swigt__p_Xapian__ValueIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ValueMapPostingSource[] = {  {&_swigt__p_Xapian__ValueMapPostingSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ValuePostingSource[] = {  {&_swigt__p_Xapian__ValuePostingSource, 0, 0, 0},  {&_swigt__p_Xapian__DecreasingValueWeightPostingSource, _p_Xapian__DecreasingValueWeightPostingSourceTo_p_Xapian__ValuePostingSource, 0, 0},  {&_swigt__p_Xapian__LatLongDistancePostingSource, _p_Xapian__LatLongDistancePostingSourceTo_p_Xapian__ValuePostingSource, 0, 0},  {&_swigt__p_Xapian__ValueMapPostingSource, _p_Xapian__ValueMapPostingSourceTo_p_Xapian__ValuePostingSource, 0, 0},  {&_swigt__p_Xapian__ValueWeightPostingSource, _p_Xapian__ValueWeightPostingSourceTo_p_Xapian__ValuePostingSource, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ValueSetMatchDecider[] = {  {&_swigt__p_Xapian__ValueSetMatchDecider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__ValueWeightPostingSource[] = {  {&_swigt__p_Xapian__ValueWeightPostingSource, 0, 0, 0},  {&_swigt__p_Xapian__DecreasingValueWeightPostingSource, _p_Xapian__DecreasingValueWeightPostingSourceTo_p_Xapian__ValueWeightPostingSource, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__Weight[] = {  {&_swigt__p_Xapian__Weight, 0, 0, 0},  {&_swigt__p_Xapian__BB2Weight, _p_Xapian__BB2WeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__BM25PlusWeight, _p_Xapian__BM25PlusWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__BM25Weight, _p_Xapian__BM25WeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__BoolWeight, _p_Xapian__BoolWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__CoordWeight, _p_Xapian__CoordWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__DLHWeight, _p_Xapian__DLHWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__DPHWeight, _p_Xapian__DPHWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__DiceWeight, _p_Xapian__DiceWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__IfB2Weight, _p_Xapian__IfB2WeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__InL2Weight, _p_Xapian__InL2WeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__IneB2Weight, _p_Xapian__IneB2WeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__LM2StageWeight, _p_Xapian__LM2StageWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__LMAbsDiscountWeight, _p_Xapian__LMAbsDiscountWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__LMDirichletWeight, _p_Xapian__LMDirichletWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__LMJMWeight, _p_Xapian__LMJMWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__PL2PlusWeight, _p_Xapian__PL2PlusWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__PL2Weight, _p_Xapian__PL2WeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__TfIdfWeight, _p_Xapian__TfIdfWeightTo_p_Xapian__Weight, 0, 0},  {&_swigt__p_Xapian__TradWeight, _p_Xapian__TradWeightTo_p_Xapian__Weight, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__WildcardError[] = {  {&_swigt__p_Xapian__WildcardError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Xapian__WritableDatabase[] = {  {&_swigt__p_Xapian__WritableDatabase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_compaction_level[] = {  {&_swigt__p_compaction_level, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_docid_order[] = {  {&_swigt__p_docid_order, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_feature_flag[] = {  {&_swigt__p_feature_flag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_flags[] = {  {&_swigt__p_flags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_stem_strategy[] = {  {&_swigt__p_stem_strategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_stop_strategy[] = {  {&_swigt__p_stop_strategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_Xapian__AssertionError,
  _swigc__p_Xapian__BB2Weight,
  _swigc__p_Xapian__BM25PlusWeight,
  _swigc__p_Xapian__BM25Weight,
  _swigc__p_Xapian__BoolWeight,
  _swigc__p_Xapian__Compactor,
  _swigc__p_Xapian__CoordWeight,
  _swigc__p_Xapian__DLHWeight,
  _swigc__p_Xapian__DPHWeight,
  _swigc__p_Xapian__Database,
  _swigc__p_Xapian__DatabaseClosedError,
  _swigc__p_Xapian__DatabaseCorruptError,
  _swigc__p_Xapian__DatabaseCreateError,
  _swigc__p_Xapian__DatabaseError,
  _swigc__p_Xapian__DatabaseLockError,
  _swigc__p_Xapian__DatabaseModifiedError,
  _swigc__p_Xapian__DatabaseNotFoundError,
  _swigc__p_Xapian__DatabaseOpeningError,
  _swigc__p_Xapian__DatabaseVersionError,
  _swigc__p_Xapian__DateRangeProcessor,
  _swigc__p_Xapian__DecreasingValueWeightPostingSource,
  _swigc__p_Xapian__DiceWeight,
  _swigc__p_Xapian__DocNotFoundError,
  _swigc__p_Xapian__Document,
  _swigc__p_Xapian__ESet,
  _swigc__p_Xapian__ESetIterator,
  _swigc__p_Xapian__Enquire,
  _swigc__p_Xapian__Error,
  _swigc__p_Xapian__ExpandDecider,
  _swigc__p_Xapian__ExpandDeciderAnd,
  _swigc__p_Xapian__ExpandDeciderFilterPrefix,
  _swigc__p_Xapian__ExpandDeciderFilterTerms,
  _swigc__p_Xapian__FeatureUnavailableError,
  _swigc__p_Xapian__FieldProcessor,
  _swigc__p_Xapian__FixedWeightPostingSource,
  _swigc__p_Xapian__GreatCircleMetric,
  _swigc__p_Xapian__IfB2Weight,
  _swigc__p_Xapian__InL2Weight,
  _swigc__p_Xapian__IneB2Weight,
  _swigc__p_Xapian__InternalError,
  _swigc__p_Xapian__InvalidArgumentError,
  _swigc__p_Xapian__InvalidOperationError,
  _swigc__p_Xapian__KeyMaker,
  _swigc__p_Xapian__LM2StageWeight,
  _swigc__p_Xapian__LMAbsDiscountWeight,
  _swigc__p_Xapian__LMDirichletWeight,
  _swigc__p_Xapian__LMJMWeight,
  _swigc__p_Xapian__LatLongCoord,
  _swigc__p_Xapian__LatLongCoords,
  _swigc__p_Xapian__LatLongCoordsIterator,
  _swigc__p_Xapian__LatLongDistanceKeyMaker,
  _swigc__p_Xapian__LatLongDistancePostingSource,
  _swigc__p_Xapian__LatLongMetric,
  _swigc__p_Xapian__LogicError,
  _swigc__p_Xapian__MSet,
  _swigc__p_Xapian__MSetIterator,
  _swigc__p_Xapian__MatchDecider,
  _swigc__p_Xapian__MatchSpy,
  _swigc__p_Xapian__MultiValueKeyMaker,
  _swigc__p_Xapian__NetworkError,
  _swigc__p_Xapian__NetworkTimeoutError,
  _swigc__p_Xapian__NumberRangeProcessor,
  _swigc__p_Xapian__PL2PlusWeight,
  _swigc__p_Xapian__PL2Weight,
  _swigc__p_Xapian__PositionIterator,
  _swigc__p_Xapian__PostingIterator,
  _swigc__p_Xapian__PostingSource,
  _swigc__p_Xapian__Query,
  _swigc__p_Xapian__QueryParser,
  _swigc__p_Xapian__QueryParserError,
  _swigc__p_Xapian__RSet,
  _swigc__p_Xapian__RangeError,
  _swigc__p_Xapian__RangeProcessor,
  _swigc__p_Xapian__Registry,
  _swigc__p_Xapian__RuntimeError,
  _swigc__p_Xapian__SerialisationError,
  _swigc__p_Xapian__SimpleStopper,
  _swigc__p_Xapian__Stem,
  _swigc__p_Xapian__StemImplementation,
  _swigc__p_Xapian__Stopper,
  _swigc__p_Xapian__TermGenerator,
  _swigc__p_Xapian__TermIterator,
  _swigc__p_Xapian__TfIdfWeight,
  _swigc__p_Xapian__TradWeight,
  _swigc__p_Xapian__UnimplementedError,
  _swigc__p_Xapian__UnitRangeProcessor,
  _swigc__p_Xapian__ValueCountMatchSpy,
  _swigc__p_Xapian__ValueIterator,
  _swigc__p_Xapian__ValueMapPostingSource,
  _swigc__p_Xapian__ValuePostingSource,
  _swigc__p_Xapian__ValueSetMatchDecider,
  _swigc__p_Xapian__ValueWeightPostingSource,
  _swigc__p_Xapian__Weight,
  _swigc__p_Xapian__WildcardError,
  _swigc__p_Xapian__WritableDatabase,
  _swigc__p_char,
  _swigc__p_compaction_level,
  _swigc__p_const_reference,
  _swigc__p_docid_order,
  _swigc__p_double,
  _swigc__p_feature_flag,
  _swigc__p_flags,
  _swigc__p_int,
  _swigc__p_reference,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__string,
  _swigc__p_stem_strategy,
  _swigc__p_stop_strategy,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  SWIG_Python_SetConstant(d, "BAD_VALUENO",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Xapian::BAD_VALUENO)));
  SWIG_Python_SetConstant(d, "DB_CREATE",SWIG_From_int(static_cast< int >(Xapian::DB_CREATE)));
  SWIG_Python_SetConstant(d, "DB_CREATE_OR_OPEN",SWIG_From_int(static_cast< int >(Xapian::DB_CREATE_OR_OPEN)));
  SWIG_Python_SetConstant(d, "DB_CREATE_OR_OVERWRITE",SWIG_From_int(static_cast< int >(Xapian::DB_CREATE_OR_OVERWRITE)));
  SWIG_Python_SetConstant(d, "DB_OPEN",SWIG_From_int(static_cast< int >(Xapian::DB_OPEN)));
  SWIG_Python_SetConstant(d, "DB_NO_SYNC",SWIG_From_int(static_cast< int >(Xapian::DB_NO_SYNC)));
  SWIG_Python_SetConstant(d, "DB_FULL_SYNC",SWIG_From_int(static_cast< int >(Xapian::DB_FULL_SYNC)));
  SWIG_Python_SetConstant(d, "DB_DANGEROUS",SWIG_From_int(static_cast< int >(Xapian::DB_DANGEROUS)));
  SWIG_Python_SetConstant(d, "DB_NO_TERMLIST",SWIG_From_int(static_cast< int >(Xapian::DB_NO_TERMLIST)));
  SWIG_Python_SetConstant(d, "DB_BACKEND_GLASS",SWIG_From_int(static_cast< int >(Xapian::DB_BACKEND_GLASS)));
  SWIG_Python_SetConstant(d, "DB_BACKEND_HONEY",SWIG_From_int(static_cast< int >(Xapian::DB_BACKEND_HONEY)));
  SWIG_Python_SetConstant(d, "DB_BACKEND_INMEMORY",SWIG_From_int(static_cast< int >(Xapian::DB_BACKEND_INMEMORY)));
  SWIG_Python_SetConstant(d, "DB_BACKEND_STUB",SWIG_From_int(static_cast< int >(Xapian::DB_BACKEND_STUB)));
  SWIG_Python_SetConstant(d, "DB_RETRY_LOCK",SWIG_From_int(static_cast< int >(Xapian::DB_RETRY_LOCK)));
  SWIG_Python_SetConstant(d, "DBCHECK_SHORT_TREE",SWIG_From_int(static_cast< int >(Xapian::DBCHECK_SHORT_TREE)));
  SWIG_Python_SetConstant(d, "DBCHECK_FULL_TREE",SWIG_From_int(static_cast< int >(Xapian::DBCHECK_FULL_TREE)));
  SWIG_Python_SetConstant(d, "DBCHECK_SHOW_FREELIST",SWIG_From_int(static_cast< int >(Xapian::DBCHECK_SHOW_FREELIST)));
  SWIG_Python_SetConstant(d, "DBCHECK_SHOW_STATS",SWIG_From_int(static_cast< int >(Xapian::DBCHECK_SHOW_STATS)));
  SWIG_Python_SetConstant(d, "DBCHECK_FIX",SWIG_From_int(static_cast< int >(Xapian::DBCHECK_FIX)));
  SWIG_Python_SetConstant(d, "DBCOMPACT_MULTIPASS",SWIG_From_int(static_cast< int >(Xapian::DBCOMPACT_MULTIPASS)));
  SWIG_Python_SetConstant(d, "DBCOMPACT_NO_RENUMBER",SWIG_From_int(static_cast< int >(Xapian::DBCOMPACT_NO_RENUMBER)));
  SWIG_Python_SetConstant(d, "DBCOMPACT_SINGLE_FILE",SWIG_From_int(static_cast< int >(Xapian::DBCOMPACT_SINGLE_FILE)));
  SWIG_Python_SetConstant(d, "DOC_ASSUME_VALID",SWIG_From_int(static_cast< int >(Xapian::DOC_ASSUME_VALID)));
  SWIG_Python_SetConstant(d, "Query_OP_AND",SWIG_From_int(static_cast< int >(Xapian::Query::OP_AND)));
  SWIG_Python_SetConstant(d, "Query_OP_OR",SWIG_From_int(static_cast< int >(Xapian::Query::OP_OR)));
  SWIG_Python_SetConstant(d, "Query_OP_AND_NOT",SWIG_From_int(static_cast< int >(Xapian::Query::OP_AND_NOT)));
  SWIG_Python_SetConstant(d, "Query_OP_XOR",SWIG_From_int(static_cast< int >(Xapian::Query::OP_XOR)));
  SWIG_Python_SetConstant(d, "Query_OP_AND_MAYBE",SWIG_From_int(static_cast< int >(Xapian::Query::OP_AND_MAYBE)));
  SWIG_Python_SetConstant(d, "Query_OP_FILTER",SWIG_From_int(static_cast< int >(Xapian::Query::OP_FILTER)));
  SWIG_Python_SetConstant(d, "Query_OP_NEAR",SWIG_From_int(static_cast< int >(Xapian::Query::OP_NEAR)));
  SWIG_Python_SetConstant(d, "Query_OP_PHRASE",SWIG_From_int(static_cast< int >(Xapian::Query::OP_PHRASE)));
  SWIG_Python_SetConstant(d, "Query_OP_VALUE_RANGE",SWIG_From_int(static_cast< int >(Xapian::Query::OP_VALUE_RANGE)));
  SWIG_Python_SetConstant(d, "Query_OP_SCALE_WEIGHT",SWIG_From_int(static_cast< int >(Xapian::Query::OP_SCALE_WEIGHT)));
  SWIG_Python_SetConstant(d, "Query_OP_ELITE_SET",SWIG_From_int(static_cast< int >(Xapian::Query::OP_ELITE_SET)));
  SWIG_Python_SetConstant(d, "Query_OP_VALUE_GE",SWIG_From_int(static_cast< int >(Xapian::Query::OP_VALUE_GE)));
  SWIG_Python_SetConstant(d, "Query_OP_VALUE_LE",SWIG_From_int(static_cast< int >(Xapian::Query::OP_VALUE_LE)));
  SWIG_Python_SetConstant(d, "Query_OP_SYNONYM",SWIG_From_int(static_cast< int >(Xapian::Query::OP_SYNONYM)));
  SWIG_Python_SetConstant(d, "Query_OP_MAX",SWIG_From_int(static_cast< int >(Xapian::Query::OP_MAX)));
  SWIG_Python_SetConstant(d, "Query_OP_WILDCARD",SWIG_From_int(static_cast< int >(Xapian::Query::OP_WILDCARD)));
  SWIG_Python_SetConstant(d, "Query_OP_EDIT_DISTANCE",SWIG_From_int(static_cast< int >(Xapian::Query::OP_EDIT_DISTANCE)));
  SWIG_Python_SetConstant(d, "Query_OP_INVALID",SWIG_From_int(static_cast< int >(Xapian::Query::OP_INVALID)));
  SWIG_Python_SetConstant(d, "Query_WILDCARD_LIMIT_ERROR",SWIG_From_int(static_cast< int >(Xapian::Query::WILDCARD_LIMIT_ERROR)));
  SWIG_Python_SetConstant(d, "Query_WILDCARD_LIMIT_FIRST",SWIG_From_int(static_cast< int >(Xapian::Query::WILDCARD_LIMIT_FIRST)));
  SWIG_Python_SetConstant(d, "Query_WILDCARD_LIMIT_MOST_FREQUENT",SWIG_From_int(static_cast< int >(Xapian::Query::WILDCARD_LIMIT_MOST_FREQUENT)));
  SWIG_Python_SetConstant(d, "Query_WILDCARD_PATTERN_MULTI",SWIG_From_int(static_cast< int >(Xapian::Query::WILDCARD_PATTERN_MULTI)));
  SWIG_Python_SetConstant(d, "Query_WILDCARD_PATTERN_SINGLE",SWIG_From_int(static_cast< int >(Xapian::Query::WILDCARD_PATTERN_SINGLE)));
  SWIG_Python_SetConstant(d, "Query_WILDCARD_PATTERN_GLOB",SWIG_From_int(static_cast< int >(Xapian::Query::WILDCARD_PATTERN_GLOB)));
  SWIG_Python_SetConstant(d, "TermGenerator_FLAG_SPELLING",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::FLAG_SPELLING)));
  SWIG_Python_SetConstant(d, "TermGenerator_FLAG_NGRAMS",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::FLAG_NGRAMS)));
  SWIG_Python_SetConstant(d, "TermGenerator_FLAG_CJK_NGRAM",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::FLAG_CJK_NGRAM)));
  SWIG_Python_SetConstant(d, "TermGenerator_FLAG_WORD_BREAKS",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::FLAG_WORD_BREAKS)));
  SWIG_Python_SetConstant(d, "TermGenerator_STEM_NONE",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STEM_NONE)));
  SWIG_Python_SetConstant(d, "TermGenerator_STEM_SOME",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STEM_SOME)));
  SWIG_Python_SetConstant(d, "TermGenerator_STEM_ALL",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STEM_ALL)));
  SWIG_Python_SetConstant(d, "TermGenerator_STEM_ALL_Z",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STEM_ALL_Z)));
  SWIG_Python_SetConstant(d, "TermGenerator_STEM_SOME_FULL_POS",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STEM_SOME_FULL_POS)));
  SWIG_Python_SetConstant(d, "TermGenerator_STOP_NONE",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STOP_NONE)));
  SWIG_Python_SetConstant(d, "TermGenerator_STOP_ALL",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STOP_ALL)));
  SWIG_Python_SetConstant(d, "TermGenerator_STOP_STEMMED",SWIG_From_int(static_cast< int >(Xapian::TermGenerator::STOP_STEMMED)));
  SWIG_Python_SetConstant(d, "MSet_SNIPPET_BACKGROUND_MODEL",SWIG_From_int(static_cast< int >(Xapian::MSet::SNIPPET_BACKGROUND_MODEL)));
  SWIG_Python_SetConstant(d, "MSet_SNIPPET_EXHAUSTIVE",SWIG_From_int(static_cast< int >(Xapian::MSet::SNIPPET_EXHAUSTIVE)));
  SWIG_Python_SetConstant(d, "MSet_SNIPPET_EMPTY_WITHOUT_MATCH",SWIG_From_int(static_cast< int >(Xapian::MSet::SNIPPET_EMPTY_WITHOUT_MATCH)));
  SWIG_Python_SetConstant(d, "MSet_SNIPPET_NGRAMS",SWIG_From_int(static_cast< int >(Xapian::MSet::SNIPPET_NGRAMS)));
  SWIG_Python_SetConstant(d, "MSet_SNIPPET_CJK_NGRAM",SWIG_From_int(static_cast< int >(Xapian::MSet::SNIPPET_CJK_NGRAM)));
  SWIG_Python_SetConstant(d, "MSet_SNIPPET_WORD_BREAKS",SWIG_From_int(static_cast< int >(Xapian::MSet::SNIPPET_WORD_BREAKS)));
  SWIG_Python_SetConstant(d, "Enquire_ASCENDING",SWIG_From_int(static_cast< int >(Xapian::Enquire::ASCENDING)));
  SWIG_Python_SetConstant(d, "Enquire_DESCENDING",SWIG_From_int(static_cast< int >(Xapian::Enquire::DESCENDING)));
  SWIG_Python_SetConstant(d, "Enquire_DONT_CARE",SWIG_From_int(static_cast< int >(Xapian::Enquire::DONT_CARE)));
  SWIG_Python_SetConstant(d, "Enquire_INCLUDE_QUERY_TERMS",SWIG_From_int(static_cast< int >(Xapian::Enquire::INCLUDE_QUERY_TERMS)));
  SWIG_Python_SetConstant(d, "Enquire_USE_EXACT_TERMFREQ",SWIG_From_int(static_cast< int >(Xapian::Enquire::USE_EXACT_TERMFREQ)));
  SWIG_Python_SetConstant(d, "RP_SUFFIX",SWIG_From_int(static_cast< int >(Xapian::RP_SUFFIX)));
  SWIG_Python_SetConstant(d, "RP_REPEATED",SWIG_From_int(static_cast< int >(Xapian::RP_REPEATED)));
  SWIG_Python_SetConstant(d, "RP_DATE_PREFER_MDY",SWIG_From_int(static_cast< int >(Xapian::RP_DATE_PREFER_MDY)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_BOOLEAN",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_BOOLEAN)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_PHRASE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_PHRASE)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_LOVEHATE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_LOVEHATE)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_BOOLEAN_ANY_CASE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_BOOLEAN_ANY_CASE)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_WILDCARD",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_WILDCARD)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_PURE_NOT",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_PURE_NOT)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_PARTIAL",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_PARTIAL)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_SPELLING_CORRECTION",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_SPELLING_CORRECTION)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_SYNONYM",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_SYNONYM)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_AUTO_SYNONYMS",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_AUTO_SYNONYMS)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_AUTO_MULTIWORD_SYNONYMS",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_AUTO_MULTIWORD_SYNONYMS)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_NGRAMS",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_NGRAMS)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_CJK_NGRAM",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_CJK_NGRAM)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_WORD_BREAKS",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_WORD_BREAKS)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_WILDCARD_MULTI",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_WILDCARD_MULTI)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_WILDCARD_SINGLE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_WILDCARD_SINGLE)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_WILDCARD_GLOB",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_WILDCARD_GLOB)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_FUZZY",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_FUZZY)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_ACCUMULATE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_ACCUMULATE)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_NO_POSITIONS",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_NO_POSITIONS)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_NO_PROPER_NOUN_HEURISTIC",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_NO_PROPER_NOUN_HEURISTIC)));
  SWIG_Python_SetConstant(d, "QueryParser_FLAG_DEFAULT",SWIG_From_int(static_cast< int >(Xapian::QueryParser::FLAG_DEFAULT)));
  SWIG_Python_SetConstant(d, "QueryParser_STEM_NONE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STEM_NONE)));
  SWIG_Python_SetConstant(d, "QueryParser_STEM_SOME",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STEM_SOME)));
  SWIG_Python_SetConstant(d, "QueryParser_STEM_ALL",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STEM_ALL)));
  SWIG_Python_SetConstant(d, "QueryParser_STEM_ALL_Z",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STEM_ALL_Z)));
  SWIG_Python_SetConstant(d, "QueryParser_STEM_SOME_FULL_POS",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STEM_SOME_FULL_POS)));
  SWIG_Python_SetConstant(d, "QueryParser_STOP_NONE",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STOP_NONE)));
  SWIG_Python_SetConstant(d, "QueryParser_STOP_ALL",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STOP_ALL)));
  SWIG_Python_SetConstant(d, "QueryParser_STOP_STEMMED",SWIG_From_int(static_cast< int >(Xapian::QueryParser::STOP_STEMMED)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_NONE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::NONE)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_BOOLEAN",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::BOOLEAN)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_SQUARE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::SQUARE)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_LOG",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::LOG)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_PIVOTED",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::PIVOTED)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_LOG_AVERAGE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::LOG_AVERAGE)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_AUG_LOG",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::AUG_LOG)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_SQRT",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::SQRT)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_AUG_AVERAGE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::AUG_AVERAGE)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_MAX",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::MAX)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wdf_norm_AUG",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wdf_norm::AUG)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_NONE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::NONE)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_TFIDF",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::TFIDF)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_SQUARE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::SQUARE)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_FREQ",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::FREQ)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_PROB",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::PROB)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_PIVOTED",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::PIVOTED)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_GLOBAL_FREQ",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::GLOBAL_FREQ)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_LOG_GLOBAL_FREQ",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::LOG_GLOBAL_FREQ)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_INCREMENTED_GLOBAL_FREQ",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::INCREMENTED_GLOBAL_FREQ)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_idf_norm_SQRT_GLOBAL_FREQ",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::idf_norm::SQRT_GLOBAL_FREQ)));
  SWIG_Python_SetConstant(d, "TfIdfWeight_wt_norm_NONE",SWIG_From_int(static_cast< int >(Xapian::TfIdfWeight::wt_norm::NONE)));
  SWIG_Python_SetConstant(d, "Compactor_STANDARD",SWIG_From_int(static_cast< int >(Xapian::Compactor::STANDARD)));
  SWIG_Python_SetConstant(d, "Compactor_FULL",SWIG_From_int(static_cast< int >(Xapian::Compactor::FULL)));
  SWIG_Python_SetConstant(d, "Compactor_FULLER",SWIG_From_int(static_cast< int >(Xapian::Compactor::FULLER)));
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

