Logo Search packages:      
Sourcecode: xapian-bindings version File versions  Download package

xapian_wrap.cc

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.30
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIG_DIRECTORS

#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};
#endif

/* -----------------------------------------------------------------------------
 *  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)
#   if (__SUNPRO_CC <= 0x560)
#     define SWIGTEMPLATEDISAMBIGUATOR template
#   else
#     define SWIGTEMPLATEDISAMBIGUATOR 
#   endif
# 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 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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  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


#include <stdlib.h>
#include <string.h>
#include <stdio.h>


/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;

typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;

typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);

typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;

typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;

static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};

static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL },
};

static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if (code >=0 && (size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}

static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if (code >=0 && (size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_Xapian(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}

#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_Xapian(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}


/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_Xapian(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else

/*  Errors in SWIG */
#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



/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * director.swg
 *
 * This file contains support for director classes so that C# proxy 
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus

#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>

namespace Swig {
  /* Director base class - not currently used in C# directors */
  class Director {
  };

  /* Base class for director exceptions */
  class DirectorException {
  protected:
    std::string swig_msg;

  public:
    DirectorException(const char* msg) : swig_msg(msg) {
    }
    DirectorException(const std::string &msg) : swig_msg(msg) {
    }
    const std::string& what() const {
      return swig_msg;
    }
    virtual ~DirectorException() {
    }
  };

  /* Pure virtual method exception */
  class DirectorPureVirtualException : public Swig::DirectorException {
  public:
    DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
    }
  };
}

#endif /* __cplusplus */



/* xapian.i: the Xapian scripting interface.
 *
 * Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2001,2002 Ananova Ltd
 * Copyright 2002,2003,2005 James Aylett
 * Copyright 2002,2003,2004,2005,2006 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

// Disable any deprecation warnings for Xapian methods/functions/classes.
#define XAPIAN_DEPRECATED(D) D
#include <xapian.h>
#include <string>
#include <vector>

using namespace std;

// If xapian-bindings configure detects that a backend was disabled (manually
// or automatically) we include a stub definition here so the bindings can
// still be built.
namespace Xapian {
#ifndef XAPIAN_HAS_QUARTZ_BACKEND
    namespace Quartz {
      static Database open() {
          throw FeatureUnavailableError("Quartz backend not supported");
      }
      static WritableDatabase open(const string &, int, int = 8192) {
          throw FeatureUnavailableError("Quartz backend not supported");
      }
    }
#endif

#ifndef XAPIAN_HAS_FLINT_BACKEND
    namespace Flint {
      static Database open() {
          throw FeatureUnavailableError("Flint backend not supported");
      }
      static WritableDatabase open(const string &, int, int = 8192) {
          throw FeatureUnavailableError("Flint backend not supported");
      }
    }
#endif

#ifndef XAPIAN_HAS_INMEMORY_BACKEND
    namespace InMemory {
      static WritableDatabase open() {
          throw FeatureUnavailableError("InMemory backend not supported");
      }
    }
#endif

#ifndef XAPIAN_HAS_MUSCAT36_BACKEND
    namespace Muscat36 {
      static Database open_da(const string &, const string &, bool = true) {
          throw FeatureUnavailableError("Muscat36 backend not supported");
      }
      static Database open_da(const string &, const string &, const string &, bool = true) {
          throw FeatureUnavailableError("Muscat36 backend not supported");
      }
      static Database open_db(const string &, size_t = 30) {
          throw FeatureUnavailableError("Muscat36 backend not supported");
      }
      static Database open_db(const string &, const string &, size_t = 30) {
          throw FeatureUnavailableError("Muscat36 backend not supported");
      }
    }
#endif

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

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

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


#include <stdexcept>


#include <string>


#include <vector>
#include <algorithm>
#include <stdexcept>


#include <map>
#include <algorithm>
#include <stdexcept>


SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
  if (code == SWIG_ValueError) {
    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
  } else {
    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
    switch(code) {
    case SWIG_MemoryError:
      exception_code = SWIG_CSharpOutOfMemoryException;
      break;
    case SWIG_IndexError:
      exception_code = SWIG_CSharpIndexOutOfRangeException;
      break;
    case SWIG_DivisionByZero:
      exception_code = SWIG_CSharpDivideByZeroException;
      break;
    case SWIG_IOError:
      exception_code = SWIG_CSharpIOException;
      break;
    case SWIG_OverflowError:
      exception_code = SWIG_CSharpOverflowException;
      break;
    case SWIG_RuntimeError:
    case SWIG_TypeError:
    case SWIG_SyntaxError:
    case SWIG_SystemError:
    case SWIG_UnknownError:
    default:
      exception_code = SWIG_CSharpApplicationException;
      break;
    }
    SWIG_CSharpSetPendingException(exception_code, msg);
  }
}


#include <stdexcept>


#include <utility>


/* csharp/util.i: custom C# typemaps for xapian-bindings
 *
 * Copyright (c) 2005,2006 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */


namespace Xapian {

// Wrap Xapian::version_string as Xapian.Version.String() as C# can't have
// functions outside a class and we don't want Xapian.Xapian.VersionString()!
class Version {
  private:
    Version();
    ~Version();
  public:
    static const char * String() { return Xapian::version_string(); }
    static int Major() { return Xapian::major_version(); }
    static int Minor() { return Xapian::minor_version(); }
    static int Revision() { return Xapian::revision(); }
};

}


// In C#, we don't get SWIG_exception in the generated C++ wrapper sources.
# define XapianException(TYPE, MSG) SWIG_CSharpException(TYPE, (MSG).c_str())


#ifndef XapianException
# define XapianException(TYPE, MSG) SWIG_exception((TYPE), (MSG).c_str())
#endif

static int XapianExceptionHandler(string & msg) {
    try {
      // Rethrow so we can look at the exception if it was a Xapian::Error.
      throw;
    } catch (const Xapian::Error &e) {
      msg = e.get_type();
      msg += ": ";
      msg += e.get_msg();


      try {
          // Re-rethrow the previous exception so we can handle the type in a
          // fine-grained way, but only in one place to avoid bloating the
          // file.
          throw;
      } catch (const Xapian::InvalidArgumentError &e) {
          return SWIG_ValueError;
      } catch (const Xapian::RangeError &e) {
          return SWIG_IndexError;
      } catch (const Xapian::DatabaseError &) {
          return SWIG_IOError;
      } catch (const Xapian::NetworkError &) {
          return SWIG_IOError;
      } catch (const Xapian::InternalError &) {
          return SWIG_RuntimeError;
      } catch (const Xapian::RuntimeError &) {
          return SWIG_RuntimeError;
      } catch (...) {
          return SWIG_UnknownError;
      }


    } catch (const char * str) {
      /* QueryParser failed to parse the query. */
      msg = "QueryParserError: ";
      msg += str;
      return SWIG_RuntimeError;
    } catch (...) {
      msg = "unknown error in Xapian";
    }
    return SWIG_UnknownError;
}

SWIGINTERN Xapian::termpos Xapian_PositionIterator_get_termpos(Xapian::PositionIterator const *self){
          return *(*self);
      }
SWIGINTERN Xapian::PositionIterator &Xapian_PositionIterator_next(Xapian::PositionIterator *self){ return ++(*self); }
SWIGINTERN bool Xapian_PositionIterator_equals(Xapian::PositionIterator const *self,Xapian::PositionIterator const &other){
          return (*self) == other;
      }
SWIGINTERN Xapian::docid Xapian_PostingIterator_get_docid(Xapian::PostingIterator const *self){
          return *(*self);
      }
SWIGINTERN Xapian::PostingIterator &Xapian_PostingIterator_next(Xapian::PostingIterator *self){ return ++(*self); }
SWIGINTERN bool Xapian_PostingIterator_equals(Xapian::PostingIterator const *self,Xapian::PostingIterator const &other){
          return (*self) == other;
      }
SWIGINTERN std::string Xapian_TermIterator_get_term(Xapian::TermIterator const *self){
          return *(*self);
      }
SWIGINTERN Xapian::TermIterator &Xapian_TermIterator_next(Xapian::TermIterator *self){ return ++(*self); }
SWIGINTERN bool Xapian_TermIterator_equals(Xapian::TermIterator const *self,Xapian::TermIterator const &other){
          return (*self) == other;
      }
SWIGINTERN std::string Xapian_ValueIterator_get_value(Xapian::ValueIterator const *self){
          return *(*self);
      }
SWIGINTERN Xapian::ValueIterator &Xapian_ValueIterator_next(Xapian::ValueIterator *self){ return ++(*self); }
SWIGINTERN bool Xapian_ValueIterator_equals(Xapian::ValueIterator const *self,Xapian::ValueIterator const &other){
          return (*self) == other;
      }
SWIGINTERN bool Xapian_MSet_is_empty(Xapian::MSet const *self){ return self->empty(); }
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 Xapian::Document const Xapian_MSet_get_document(Xapian::MSet const *self,Xapian::doccount i){
          return ((*self)[i]).get_document();
      }
SWIGINTERN Xapian::docid Xapian_MSet_get_docid(Xapian::MSet const *self,Xapian::doccount i){
          return *((*self)[i]);
      }
SWIGINTERN Xapian::docid Xapian_MSet_get_document_id(Xapian::MSet const *self,Xapian::doccount i){
          return *((*self)[i]);
      }
SWIGINTERN Xapian::docid Xapian_MSetIterator_get_docid(Xapian::MSetIterator const *self){
          return *(*self);
      }
SWIGINTERN Xapian::MSetIterator &Xapian_MSetIterator_next(Xapian::MSetIterator *self){ return ++(*self); }
SWIGINTERN Xapian::MSetIterator &Xapian_MSetIterator_prev(Xapian::MSetIterator *self){ return --(*self); }
SWIGINTERN bool Xapian_MSetIterator_equals(Xapian::MSetIterator const *self,Xapian::MSetIterator const &other){
          return (*self) == other;
      }
SWIGINTERN bool Xapian_ESet_is_empty(Xapian::ESet const *self){ return self->empty(); }
SWIGINTERN std::string Xapian_ESetIterator_get_termname(Xapian::ESetIterator const *self){
          return *(*self);
      }
SWIGINTERN Xapian::ESetIterator &Xapian_ESetIterator_next(Xapian::ESetIterator *self){ return ++(*self); }
SWIGINTERN Xapian::ESetIterator &Xapian_ESetIterator_prev(Xapian::ESetIterator *self){ return --(*self); }
SWIGINTERN bool Xapian_ESetIterator_equals(Xapian::ESetIterator const *self,Xapian::ESetIterator const &other){
          return (*self) == other;
      }
SWIGINTERN bool Xapian_RSet_is_empty(Xapian::RSet const *self){ return self->empty(); }
SWIGINTERN Xapian::Query *new_Xapian_Query__SWIG_6(Xapian::Query::op op,std::vector<std::string > const &subqs,Xapian::termcount param=0){
            return new Xapian::Query(op, subqs.begin(), subqs.end(), param);
          }
SWIGINTERN Xapian::Query *new_Xapian_Query__SWIG_8(Xapian::Query::op op,std::vector<Xapian::Query > const &subqs,Xapian::termcount param=0){
            return new Xapian::Query(op, subqs.begin(), subqs.end(), param);
          }


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

#include "xapian_wrap.h"

SwigDirector_MatchDecider::SwigDirector_MatchDecider() : Xapian::MatchDecider(), Swig::Director() {
  swig_init_callbacks();
}

int SwigDirector_MatchDecider::operator ()(Xapian::Document const &doc) const {
  int c_result ;
  int jresult  = 0 ;
  void * jdoc = 0 ;
  
  if (!swig_callbackApply) {
    throw Swig::DirectorPureVirtualException("Xapian::MatchDecider::operator ()");
  } else {
    jdoc = (Xapian::Document *) &doc; 
    jresult = (int) swig_callbackApply(jdoc);
    c_result = (int)jresult; 
  }
  return c_result;
}

SwigDirector_MatchDecider::~SwigDirector_MatchDecider() {
  
}


void SwigDirector_MatchDecider::swig_connect_director(SWIG_Callback0_t callbackApply) {
  swig_callbackApply = callbackApply;
}

void SwigDirector_MatchDecider::swig_init_callbacks() {
  swig_callbackApply = 0;
}

SwigDirector_Stopper::SwigDirector_Stopper() : Xapian::Stopper(), Swig::Director() {
  swig_init_callbacks();
}

bool SwigDirector_Stopper::operator ()(std::string const &term) const {
  bool c_result ;
  unsigned int jresult  = 0 ;
  char * jterm = 0 ;
  
  if (!swig_callbackApply) {
    throw Swig::DirectorPureVirtualException("Xapian::Stopper::operator ()");
  } else {
    jterm = SWIG_csharp_string_callback((&term)->c_str()); 
    jresult = (unsigned int) swig_callbackApply(jterm);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

SwigDirector_Stopper::~SwigDirector_Stopper() {
  
}


std::string SwigDirector_Stopper::get_description() const {
  std::string c_result ;
  char * jresult  = 0 ;
  
  if (!swig_callbackGetDescription) {
    return Xapian::Stopper::get_description();
  } else {
    jresult = (char *) swig_callbackGetDescription();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result = std::string(jresult); 
  }
  return c_result;
}

void SwigDirector_Stopper::swig_connect_director(SWIG_Callback0_t callbackApply, SWIG_Callback1_t callbackGetDescription) {
  swig_callbackApply = callbackApply;
  swig_callbackGetDescription = callbackGetDescription;
}

void SwigDirector_Stopper::swig_init_callbacks() {
  swig_callbackApply = 0;
  swig_callbackGetDescription = 0;
}


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT char * SWIGSTDCALL CSharp_Version_String() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)Xapian::Version::String();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_Major() {
  int jresult ;
  int result;
  
  result = (int)Xapian::Version::Major();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_Minor() {
  int jresult ;
  int result;
  
  result = (int)Xapian::Version::Minor();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_Revision() {
  int jresult ;
  int result;
  
  result = (int)Xapian::Version::Revision();
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_XapianVersionString() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)Xapian::xapian_version_string();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XapianMajorVersion() {
  int jresult ;
  int result;
  
  result = (int)Xapian::xapian_major_version();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XapianMinorVersion() {
  int jresult ;
  int result;
  
  result = (int)Xapian::xapian_minor_version();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_XapianRevision() {
  int jresult ;
  int result;
  
  result = (int)Xapian::xapian_revision();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PositionIterator__SWIG_0() {
  void * jresult ;
  Xapian::PositionIterator *result = 0 ;
  
  {
    try {
      result = (Xapian::PositionIterator *)new Xapian::PositionIterator();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PositionIterator__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::PositionIterator *arg1 = 0 ;
  Xapian::PositionIterator *result = 0 ;
  
  arg1 = (Xapian::PositionIterator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::PositionIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::PositionIterator *)new Xapian::PositionIterator((Xapian::PositionIterator const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PositionIterator(void * jarg1) {
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  
  arg1 = (Xapian::PositionIterator *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PositionIterator_GetTermPos(void * jarg1) {
  unsigned int jresult ;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::termpos result;
  
  arg1 = (Xapian::PositionIterator *)jarg1; 
  {
    try {
      result = (Xapian::termpos)Xapian_PositionIterator_get_termpos((Xapian::PositionIterator const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PositionIterator_Next(void * jarg1) {
  void * jresult ;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::PositionIterator *result = 0 ;
  
  arg1 = (Xapian::PositionIterator *)jarg1; 
  {
    try {
      {
        Xapian::PositionIterator &_result_ref = Xapian_PositionIterator_next(arg1);
        result = (Xapian::PositionIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PositionIterator_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::PositionIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::PositionIterator *)jarg1; 
  arg2 = (Xapian::PositionIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::PositionIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Xapian_PositionIterator_equals((Xapian::PositionIterator const *)arg1,(Xapian::PositionIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PositionIterator_SkipTo(void * jarg1, unsigned int jarg2) {
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  Xapian::termpos arg2 ;
  
  arg1 = (Xapian::PositionIterator *)jarg1; 
  arg2 = (Xapian::termpos)jarg2; 
  {
    try {
      (arg1)->skip_to(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_PositionIterator_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::PositionIterator *arg1 = (Xapian::PositionIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::PositionIterator *)jarg1; 
  {
    try {
      result = ((Xapian::PositionIterator const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PostingIterator__SWIG_0() {
  void * jresult ;
  Xapian::PostingIterator *result = 0 ;
  
  {
    try {
      result = (Xapian::PostingIterator *)new Xapian::PostingIterator();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PostingIterator__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::PostingIterator *arg1 = 0 ;
  Xapian::PostingIterator *result = 0 ;
  
  arg1 = (Xapian::PostingIterator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::PostingIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::PostingIterator *)new Xapian::PostingIterator((Xapian::PostingIterator const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PostingIterator(void * jarg1) {
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PostingIterator_GetDocId(void * jarg1) {
  unsigned int jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::docid result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      result = (Xapian::docid)Xapian_PostingIterator_get_docid((Xapian::PostingIterator const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PostingIterator_Next(void * jarg1) {
  void * jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PostingIterator *result = 0 ;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      {
        Xapian::PostingIterator &_result_ref = Xapian_PostingIterator_next(arg1);
        result = (Xapian::PostingIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PostingIterator_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PostingIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  arg2 = (Xapian::PostingIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::PostingIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Xapian_PostingIterator_equals((Xapian::PostingIterator const *)arg1,(Xapian::PostingIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PostingIterator_SkipTo(void * jarg1, unsigned int jarg2) {
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::docid arg2 ;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      (arg1)->skip_to(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_PostingIterator_GetDocLength(void * jarg1) {
  double jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::doclength result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      result = (Xapian::doclength)((Xapian::PostingIterator const *)arg1)->get_doclength();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PostingIterator_GetWdf(void * jarg1) {
  unsigned int jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::PostingIterator const *)arg1)->get_wdf();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PostingIterator_PositionListBegin(void * jarg1) {
  void * jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PositionIterator result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      result = (arg1)->positionlist_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PositionIterator((Xapian::PositionIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PostingIterator_PositionListEnd(void * jarg1) {
  void * jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  Xapian::PositionIterator result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      result = (arg1)->positionlist_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PositionIterator((Xapian::PositionIterator &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_PostingIterator_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::PostingIterator *arg1 = (Xapian::PostingIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::PostingIterator *)jarg1; 
  {
    try {
      result = ((Xapian::PostingIterator const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_TermIterator__SWIG_0() {
  void * jresult ;
  Xapian::TermIterator *result = 0 ;
  
  {
    try {
      result = (Xapian::TermIterator *)new Xapian::TermIterator();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_TermIterator__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::TermIterator *arg1 = 0 ;
  Xapian::TermIterator *result = 0 ;
  
  arg1 = (Xapian::TermIterator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::TermIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::TermIterator *)new Xapian::TermIterator((Xapian::TermIterator const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_TermIterator(void * jarg1) {
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_TermIterator_GetTerm(void * jarg1) {
  char * jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      result = Xapian_TermIterator_get_term((Xapian::TermIterator const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_TermIterator_Next(void * jarg1) {
  void * jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::TermIterator *result = 0 ;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      {
        Xapian::TermIterator &_result_ref = Xapian_TermIterator_next(arg1);
        result = (Xapian::TermIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_TermIterator_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::TermIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  arg2 = (Xapian::TermIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::TermIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Xapian_TermIterator_equals((Xapian::TermIterator const *)arg1,(Xapian::TermIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_TermIterator_SkipTo(void * jarg1, char * jarg2) {
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->skip_to((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_TermIterator_GetWdf(void * jarg1) {
  unsigned int jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::TermIterator const *)arg1)->get_wdf();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_TermIterator_GetTermFreq(void * jarg1) {
  unsigned int jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::TermIterator const *)arg1)->get_termfreq();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_TermIterator_PositionListBegin(void * jarg1) {
  void * jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::PositionIterator result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      result = (arg1)->positionlist_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PositionIterator((Xapian::PositionIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_TermIterator_PositionListEnd(void * jarg1) {
  void * jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  Xapian::PositionIterator result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      result = (arg1)->positionlist_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PositionIterator((Xapian::PositionIterator &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_TermIterator_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::TermIterator *arg1 = (Xapian::TermIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::TermIterator *)jarg1; 
  {
    try {
      result = ((Xapian::TermIterator const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ValueIterator__SWIG_0() {
  void * jresult ;
  Xapian::ValueIterator *result = 0 ;
  
  {
    try {
      result = (Xapian::ValueIterator *)new Xapian::ValueIterator();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ValueIterator__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::ValueIterator *arg1 = 0 ;
  Xapian::ValueIterator *result = 0 ;
  
  arg1 = (Xapian::ValueIterator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::ValueIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::ValueIterator *)new Xapian::ValueIterator((Xapian::ValueIterator const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ValueIterator(void * jarg1) {
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  
  arg1 = (Xapian::ValueIterator *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_ValueIterator_GetValue(void * jarg1) {
  char * jresult ;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::ValueIterator *)jarg1; 
  {
    try {
      result = Xapian_ValueIterator_get_value((Xapian::ValueIterator const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ValueIterator_Next(void * jarg1) {
  void * jresult ;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::ValueIterator *result = 0 ;
  
  arg1 = (Xapian::ValueIterator *)jarg1; 
  {
    try {
      {
        Xapian::ValueIterator &_result_ref = Xapian_ValueIterator_next(arg1);
        result = (Xapian::ValueIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ValueIterator_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::ValueIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::ValueIterator *)jarg1; 
  arg2 = (Xapian::ValueIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::ValueIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Xapian_ValueIterator_equals((Xapian::ValueIterator const *)arg1,(Xapian::ValueIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ValueIterator_GetValueNo(void * jarg1) {
  unsigned int jresult ;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  Xapian::valueno result;
  
  arg1 = (Xapian::ValueIterator *)jarg1; 
  {
    try {
      result = (Xapian::valueno)(arg1)->get_valueno();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_ValueIterator_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::ValueIterator *arg1 = (Xapian::ValueIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::ValueIterator *)jarg1; 
  {
    try {
      result = ((Xapian::ValueIterator const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Document__SWIG_0() {
  void * jresult ;
  Xapian::Document *result = 0 ;
  
  {
    try {
      result = (Xapian::Document *)new Xapian::Document();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Document__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::Document *arg1 = 0 ;
  Xapian::Document *result = 0 ;
  
  arg1 = (Xapian::Document *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Document const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Document *)new Xapian::Document((Xapian::Document const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Document(void * jarg1) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Document_GetValue(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::valueno arg2 ;
  std::string result;
  
  arg1 = (Xapian::Document *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->get_value(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddValue(void * jarg1, unsigned int jarg2, char * jarg3) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::valueno arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      (arg1)->add_value(arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_RemoveValue(void * jarg1, unsigned int jarg2) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::valueno arg2 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  {
    try {
      (arg1)->remove_value(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_ClearValues(void * jarg1) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      (arg1)->clear_values();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Document_GetData(void * jarg1) {
  char * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->get_data();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_SetData(void * jarg1, char * jarg2) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->set_data((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddPosting__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termpos arg3 ;
  Xapian::termcount arg4 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::termpos)jarg3; 
  arg4 = (Xapian::termcount)jarg4; 
  {
    try {
      (arg1)->add_posting((std::string const &)*arg2,arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddPosting__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termpos arg3 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::termpos)jarg3; 
  {
    try {
      (arg1)->add_posting((std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddTerm__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termcount arg3 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::termcount)jarg3; 
  {
    try {
      (arg1)->add_term((std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddTerm__SWIG_1(void * jarg1, char * jarg2) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->add_term((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddTermNopos__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termcount arg3 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::termcount)jarg3; 
  {
    try {
      (arg1)->add_term_nopos((std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_AddTermNopos__SWIG_1(void * jarg1, char * jarg2) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->add_term_nopos((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_RemovePosting__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termpos arg3 ;
  Xapian::termcount arg4 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::termpos)jarg3; 
  arg4 = (Xapian::termcount)jarg4; 
  {
    try {
      (arg1)->remove_posting((std::string const &)*arg2,arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_RemovePosting__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termpos arg3 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::termpos)jarg3; 
  {
    try {
      (arg1)->remove_posting((std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_RemoveTerm(void * jarg1, char * jarg2) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->remove_term((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Document_ClearTerms(void * jarg1) {
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      (arg1)->clear_terms();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Document_TermListCount(void * jarg1) {
  unsigned int jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::Document const *)arg1)->termlist_count();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Document_TermListBegin(void * jarg1) {
  void * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->termlist_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Document_TermListEnd(void * jarg1) {
  void * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->termlist_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Document_ValuesCount(void * jarg1) {
  unsigned int jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::Document const *)arg1)->values_count();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Document_ValuesBegin(void * jarg1) {
  void * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::ValueIterator result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->values_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ValueIterator((Xapian::ValueIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Document_ValuesEnd(void * jarg1) {
  void * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  Xapian::ValueIterator result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->values_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ValueIterator((Xapian::ValueIterator &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Document_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::Document *arg1 = (Xapian::Document *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Document *)jarg1; 
  {
    try {
      result = ((Xapian::Document const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_MSet__SWIG_0() {
  void * jresult ;
  Xapian::MSet *result = 0 ;
  
  {
    try {
      result = (Xapian::MSet *)new Xapian::MSet();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_MSet__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::MSet *arg1 = 0 ;
  Xapian::MSet *result = 0 ;
  
  arg1 = (Xapian::MSet *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSet const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::MSet *)new Xapian::MSet((Xapian::MSet const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_MSet(void * jarg1) {
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_MSet_Fetch__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  Xapian::MSetIterator *arg3 = 0 ;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator & type is null", 0);
    return ;
  } 
  arg3 = (Xapian::MSetIterator *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator & type is null", 0);
    return ;
  } 
  {
    try {
      ((Xapian::MSet const *)arg1)->fetch(*arg2,*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_MSet_Fetch__SWIG_1(void * jarg1, void * jarg2) {
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator & type is null", 0);
    return ;
  } 
  {
    try {
      ((Xapian::MSet const *)arg1)->fetch(*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_MSet_Fetch__SWIG_2(void * jarg1) {
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      ((Xapian::MSet const *)arg1)->fetch();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_MSet_ConvertToPercent__SWIG_0(void * jarg1, double jarg2) {
  int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::weight arg2 ;
  Xapian::percent result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::weight)jarg2; 
  {
    try {
      result = (Xapian::percent)((Xapian::MSet const *)arg1)->convert_to_percent(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_MSet_ConvertToPercent__SWIG_1(void * jarg1, void * jarg2) {
  int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  Xapian::percent result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::percent)((Xapian::MSet const *)arg1)->convert_to_percent((Xapian::MSetIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetTermFreq(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string arg2 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  arg2 = std::string(jarg2); 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_termfreq(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_MSet_GetTermWeight(void * jarg1, char * jarg2) {
  double jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string arg2 ;
  Xapian::weight result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  arg2 = std::string(jarg2); 
  {
    try {
      result = (Xapian::weight)((Xapian::MSet const *)arg1)->get_termweight(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetFirstItem(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_firstitem();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetMatchesLowerBound(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_matches_lower_bound();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetMatchesEstimated(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_matches_estimated();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetMatchesUpperBound(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSet const *)arg1)->get_matches_upper_bound();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_MSet_GetMaxPossible(void * jarg1) {
  double jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::weight)(arg1)->get_max_possible();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_MSet_GetMaxAttained(void * jarg1) {
  double jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::weight)(arg1)->get_max_attained();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_Size(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSet const *)arg1)->size();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_Empty(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  bool result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (bool)((Xapian::MSet const *)arg1)->empty();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_IsEmpty(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  bool result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = (bool)Xapian_MSet_is_empty((Xapian::MSet const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSet_Begin(void * jarg1) {
  void * jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = ((Xapian::MSet const *)arg1)->begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSetIterator((Xapian::MSetIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSet_End(void * jarg1) {
  void * jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = ((Xapian::MSet const *)arg1)->end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSetIterator((Xapian::MSetIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSet_Back(void * jarg1) {
  void * jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::MSetIterator result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = ((Xapian::MSet const *)arg1)->back();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSetIterator((Xapian::MSetIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSet_GetHit(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::MSetIterator result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  {
    try {
      result = Xapian_MSet_get_hit((Xapian::MSet const *)arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSetIterator((Xapian::MSetIterator &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_MSet_GetDocumentPercentage(void * jarg1, unsigned int jarg2) {
  int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  int result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  {
    try {
      result = (int)Xapian_MSet_get_document_percentage((Xapian::MSet const *)arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSet_GetDocument(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::Document result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  {
    try {
      result = Xapian_MSet_get_document((Xapian::MSet const *)arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Document((Xapian::Document &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetDocId(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::docid result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  {
    try {
      result = (Xapian::docid)Xapian_MSet_get_docid((Xapian::MSet const *)arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSet_GetDocumentId(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::docid result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  {
    try {
      result = (Xapian::docid)Xapian_MSet_get_document_id((Xapian::MSet const *)arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_MSet_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::MSet *arg1 = (Xapian::MSet *) 0 ;
  std::string result;
  
  arg1 = (Xapian::MSet *)jarg1; 
  {
    try {
      result = ((Xapian::MSet const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_MSetIterator__SWIG_0() {
  void * jresult ;
  Xapian::MSetIterator *result = 0 ;
  
  {
    try {
      result = (Xapian::MSetIterator *)new Xapian::MSetIterator();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_MSetIterator__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::MSetIterator *arg1 = 0 ;
  Xapian::MSetIterator *result = 0 ;
  
  arg1 = (Xapian::MSetIterator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::MSetIterator *)new Xapian::MSetIterator((Xapian::MSetIterator const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_MSetIterator(void * jarg1) {
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSetIterator_GetDocId(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::docid result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = (Xapian::docid)Xapian_MSetIterator_get_docid((Xapian::MSetIterator const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSetIterator_Next(void * jarg1) {
  void * jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSetIterator *result = 0 ;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      {
        Xapian::MSetIterator &_result_ref = Xapian_MSetIterator_next(arg1);
        result = (Xapian::MSetIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSetIterator_Prev(void * jarg1) {
  void * jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSetIterator *result = 0 ;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      {
        Xapian::MSetIterator &_result_ref = Xapian_MSetIterator_prev(arg1);
        result = (Xapian::MSetIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSetIterator_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Xapian_MSetIterator_equals((Xapian::MSetIterator const *)arg1,(Xapian::MSetIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_MSetIterator_GetDocument(void * jarg1) {
  void * jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::Document result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = ((Xapian::MSetIterator const *)arg1)->get_document();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Document((Xapian::Document &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSetIterator_GetRank(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSetIterator const *)arg1)->get_rank();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_MSetIterator_GetWeight(void * jarg1) {
  double jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::MSetIterator const *)arg1)->get_weight();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_MSetIterator_GetCollapseCount(void * jarg1) {
  unsigned int jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::MSetIterator const *)arg1)->get_collapse_count();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_MSetIterator_GetPercent(void * jarg1) {
  int jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  Xapian::percent result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = (Xapian::percent)((Xapian::MSetIterator const *)arg1)->get_percent();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_MSetIterator_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::MSetIterator *arg1 = (Xapian::MSetIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::MSetIterator *)jarg1; 
  {
    try {
      result = ((Xapian::MSetIterator const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESet__SWIG_0() {
  void * jresult ;
  Xapian::ESet *result = 0 ;
  
  {
    try {
      result = (Xapian::ESet *)new Xapian::ESet();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESet__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::ESet *arg1 = 0 ;
  Xapian::ESet *result = 0 ;
  
  arg1 = (Xapian::ESet *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::ESet const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::ESet *)new Xapian::ESet((Xapian::ESet const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ESet(void * jarg1) {
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESet_GetEbound(void * jarg1) {
  unsigned int jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::ESet const *)arg1)->get_ebound();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESet_Size(void * jarg1) {
  unsigned int jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::ESet const *)arg1)->size();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESet_Empty(void * jarg1) {
  unsigned int jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  bool result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = (bool)((Xapian::ESet const *)arg1)->empty();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESet_IsEmpty(void * jarg1) {
  unsigned int jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  bool result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = (bool)Xapian_ESet_is_empty((Xapian::ESet const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ESet_Begin(void * jarg1) {
  void * jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  Xapian::ESetIterator result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = ((Xapian::ESet const *)arg1)->begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESetIterator((Xapian::ESetIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ESet_End(void * jarg1) {
  void * jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  Xapian::ESetIterator result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = ((Xapian::ESet const *)arg1)->end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESetIterator((Xapian::ESetIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ESet_Back(void * jarg1) {
  void * jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  Xapian::ESetIterator result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = ((Xapian::ESet const *)arg1)->back();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESetIterator((Xapian::ESetIterator &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_ESet_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::ESet *arg1 = (Xapian::ESet *) 0 ;
  std::string result;
  
  arg1 = (Xapian::ESet *)jarg1; 
  {
    try {
      result = ((Xapian::ESet const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESetIterator__SWIG_0() {
  void * jresult ;
  Xapian::ESetIterator *result = 0 ;
  
  {
    try {
      result = (Xapian::ESetIterator *)new Xapian::ESetIterator();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESetIterator__SWIG_1(void * jarg1) {
  void * jresult ;
  Xapian::ESetIterator *arg1 = 0 ;
  Xapian::ESetIterator *result = 0 ;
  
  arg1 = (Xapian::ESetIterator *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::ESetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::ESetIterator *)new Xapian::ESetIterator((Xapian::ESetIterator const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ESetIterator(void * jarg1) {
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_ESetIterator_GetTermName(void * jarg1) {
  char * jresult ;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  {
    try {
      result = Xapian_ESetIterator_get_termname((Xapian::ESetIterator const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ESetIterator_Next(void * jarg1) {
  void * jresult ;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESetIterator *result = 0 ;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  {
    try {
      {
        Xapian::ESetIterator &_result_ref = Xapian_ESetIterator_next(arg1);
        result = (Xapian::ESetIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ESetIterator_Prev(void * jarg1) {
  void * jresult ;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESetIterator *result = 0 ;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  {
    try {
      {
        Xapian::ESetIterator &_result_ref = Xapian_ESetIterator_prev(arg1);
        result = (Xapian::ESetIterator *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESetIterator_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::ESetIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  arg2 = (Xapian::ESetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::ESetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)Xapian_ESetIterator_equals((Xapian::ESetIterator const *)arg1,(Xapian::ESetIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_ESetIterator_GetWeight(void * jarg1) {
  double jresult ;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::ESetIterator const *)arg1)->get_weight();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_ESetIterator_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::ESetIterator *arg1 = (Xapian::ESetIterator *) 0 ;
  std::string result;
  
  arg1 = (Xapian::ESetIterator *)jarg1; 
  {
    try {
      result = ((Xapian::ESetIterator const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RSet__SWIG_0(void * jarg1) {
  void * jresult ;
  Xapian::RSet *arg1 = 0 ;
  Xapian::RSet *result = 0 ;
  
  arg1 = (Xapian::RSet *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::RSet const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::RSet *)new Xapian::RSet((Xapian::RSet const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_RSet__SWIG_1() {
  void * jresult ;
  Xapian::RSet *result = 0 ;
  
  {
    try {
      result = (Xapian::RSet *)new Xapian::RSet();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_RSet(void * jarg1) {
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  
  arg1 = (Xapian::RSet *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RSet_Size(void * jarg1) {
  unsigned int jresult ;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::RSet *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::RSet const *)arg1)->size();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RSet_Empty(void * jarg1) {
  unsigned int jresult ;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  bool result;
  
  arg1 = (Xapian::RSet *)jarg1; 
  {
    try {
      result = (bool)((Xapian::RSet const *)arg1)->empty();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RSet_IsEmpty(void * jarg1) {
  unsigned int jresult ;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  bool result;
  
  arg1 = (Xapian::RSet *)jarg1; 
  {
    try {
      result = (bool)Xapian_RSet_is_empty((Xapian::RSet const *)arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RSet_AddDocument__SWIG_0(void * jarg1, unsigned int jarg2) {
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::docid arg2 ;
  
  arg1 = (Xapian::RSet *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      (arg1)->add_document(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_RSet_AddDocument__SWIG_1(void * jarg1, void * jarg2) {
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  
  arg1 = (Xapian::RSet *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add_document(*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_RSet_RemoveDocument__SWIG_0(void * jarg1, unsigned int jarg2) {
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::docid arg2 ;
  
  arg1 = (Xapian::RSet *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      (arg1)->remove_document(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_RSet_RemoveDocument__SWIG_1(void * jarg1, void * jarg2) {
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  
  arg1 = (Xapian::RSet *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->remove_document(*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RSet_Contains__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::docid arg2 ;
  bool result;
  
  arg1 = (Xapian::RSet *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = (bool)(arg1)->contains(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RSet_Contains__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::RSet *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (bool)(arg1)->contains(*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RSet_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::RSet *arg1 = (Xapian::RSet *) 0 ;
  std::string result;
  
  arg1 = (Xapian::RSet *)jarg1; 
  {
    try {
      result = ((Xapian::RSet const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_MatchDecider_Apply(void * jarg1, void * jarg2) {
  int jresult ;
  Xapian::MatchDecider *arg1 = (Xapian::MatchDecider *) 0 ;
  Xapian::Document *arg2 = 0 ;
  int result;
  
  arg1 = (Xapian::MatchDecider *)jarg1; 
  arg2 = (Xapian::Document *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Document const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (int)((Xapian::MatchDecider const *)arg1)->operator ()((Xapian::Document const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_MatchDecider(void * jarg1) {
  Xapian::MatchDecider *arg1 = (Xapian::MatchDecider *) 0 ;
  
  arg1 = (Xapian::MatchDecider *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_MatchDecider() {
  void * jresult ;
  Xapian::MatchDecider *result = 0 ;
  
  {
    try {
      result = (Xapian::MatchDecider *)new SwigDirector_MatchDecider();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_MatchDecider_director_connect(void *objarg, SwigDirector_MatchDecider::SWIG_Callback0_t callback0) {
  Xapian::MatchDecider *obj = (Xapian::MatchDecider *)objarg;
  SwigDirector_MatchDecider *director = dynamic_cast<SwigDirector_MatchDecider *>(obj);
  if (director) {
    director->swig_connect_director(callback0);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Enquire(void * jarg1) {
  void * jresult ;
  Xapian::Database *arg1 = 0 ;
  Xapian::Enquire *result = 0 ;
  
  arg1 = (Xapian::Database *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Database const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Enquire *)new Xapian::Enquire((Xapian::Database const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Enquire(void * jarg1) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetQuery__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Query *arg2 = 0 ;
  Xapian::termcount arg3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::Query *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Query const & type is null", 0);
    return ;
  } 
  arg3 = (Xapian::termcount)jarg3; 
  {
    try {
      (arg1)->set_query((Xapian::Query const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetQuery__SWIG_1(void * jarg1, void * jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Query *arg2 = 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::Query *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Query const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->set_query((Xapian::Query const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetQuery(void * jarg1) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  {
    try {
      {
        Xapian::Query const &_result_ref = (arg1)->get_query();
        result = (Xapian::Query *) &_result_ref;
      }
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetWeightingScheme(void * jarg1, void * jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Weight *arg2 = 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::Weight *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Weight const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->set_weighting_scheme((Xapian::Weight const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetCollapseKey(void * jarg1, unsigned int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  {
    try {
      (arg1)->set_collapse_key(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetDocidOrder(void * jarg1, int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::Enquire::docid_order arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::Enquire::docid_order)jarg2; 
  {
    try {
      (arg1)->set_docid_order(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortForward(void * jarg1, unsigned int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  bool arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      (arg1)->set_sort_forward(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetCutoff__SWIG_0(void * jarg1, int jarg2, double jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  int arg2 ;
  Xapian::weight arg3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (Xapian::weight)jarg3; 
  {
    try {
      (arg1)->set_cutoff(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetCutoff__SWIG_1(void * jarg1, int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  int arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->set_cutoff(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSorting__SWIG_0(void * jarg1, unsigned int jarg2, int jarg3, unsigned int jarg4) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  int arg3 ;
  bool arg4 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      (arg1)->set_sorting(arg2,arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSorting__SWIG_1(void * jarg1, unsigned int jarg2, int jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  int arg3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->set_sorting(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByRelevance(void * jarg1) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  {
    try {
      (arg1)->set_sort_by_relevance();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByValue__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      (arg1)->set_sort_by_value(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByValue__SWIG_1(void * jarg1, unsigned int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  {
    try {
      (arg1)->set_sort_by_value(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByValueThenRelevance__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      (arg1)->set_sort_by_value_then_relevance(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByValueThenRelevance__SWIG_1(void * jarg1, unsigned int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  {
    try {
      (arg1)->set_sort_by_value_then_relevance(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByRelevanceThenValue__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  bool arg3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      (arg1)->set_sort_by_relevance_then_value(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetSortByRelevanceThenValue__SWIG_1(void * jarg1, unsigned int jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::valueno arg2 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::valueno)jarg2; 
  {
    try {
      (arg1)->set_sort_by_relevance_then_value(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_SetBias(void * jarg1, double jarg2, void * jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::weight arg2 ;
  time_t arg3 ;
  time_t *argp3 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::weight)jarg2; 
  argp3 = (time_t *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null time_t", 0);
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      (arg1)->set_bias(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMSet__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  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 ;
  Xapian::MSet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  arg3 = (Xapian::doccount)jarg3; 
  arg4 = (Xapian::doccount)jarg4; 
  arg5 = (Xapian::RSet *)jarg5; 
  arg6 = (Xapian::MatchDecider *)jarg6; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,arg4,(Xapian::RSet const *)arg5,(Xapian::MatchDecider const *)arg6);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSet((Xapian::MSet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMSet__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::doccount arg4 ;
  Xapian::RSet *arg5 = (Xapian::RSet *) 0 ;
  Xapian::MSet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  arg3 = (Xapian::doccount)jarg3; 
  arg4 = (Xapian::doccount)jarg4; 
  arg5 = (Xapian::RSet *)jarg5; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,arg4,(Xapian::RSet const *)arg5);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSet((Xapian::MSet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMSet__SWIG_2(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::doccount arg4 ;
  Xapian::MSet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  arg3 = (Xapian::doccount)jarg3; 
  arg4 = (Xapian::doccount)jarg4; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSet((Xapian::MSet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMSet__SWIG_3(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::MSet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  arg3 = (Xapian::doccount)jarg3; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSet((Xapian::MSet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMSet__SWIG_4(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::RSet *arg4 = (Xapian::RSet *) 0 ;
  Xapian::MatchDecider *arg5 = (Xapian::MatchDecider *) 0 ;
  Xapian::MSet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  arg3 = (Xapian::doccount)jarg3; 
  arg4 = (Xapian::RSet *)jarg4; 
  arg5 = (Xapian::MatchDecider *)jarg5; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,(Xapian::RSet const *)arg4,(Xapian::MatchDecider const *)arg5);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSet((Xapian::MSet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMSet__SWIG_5(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::doccount arg2 ;
  Xapian::doccount arg3 ;
  Xapian::RSet *arg4 = (Xapian::RSet *) 0 ;
  Xapian::MSet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::doccount)jarg2; 
  arg3 = (Xapian::doccount)jarg3; 
  arg4 = (Xapian::RSet *)jarg4; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_mset(arg2,arg3,(Xapian::RSet const *)arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::MSet((Xapian::MSet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetESet__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3, int jarg4, double jarg5, void * jarg6) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  int arg4 ;
  double arg5 ;
  Xapian::ExpandDecider *arg6 = (Xapian::ExpandDecider *) 0 ;
  Xapian::ESet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::RSet *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::RSet const & type is null", 0);
    return 0;
  } 
  arg4 = (int)jarg4; 
  arg5 = (double)jarg5; 
  arg6 = (Xapian::ExpandDecider *)jarg6; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,arg4,arg5,(Xapian::ExpandDecider const *)arg6);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESet((Xapian::ESet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetESet__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3, int jarg4, double jarg5) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  int arg4 ;
  double arg5 ;
  Xapian::ESet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::RSet *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::RSet const & type is null", 0);
    return 0;
  } 
  arg4 = (int)jarg4; 
  arg5 = (double)jarg5; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,arg4,arg5);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESet((Xapian::ESet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetESet__SWIG_2(void * jarg1, unsigned int jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  int arg4 ;
  Xapian::ESet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::RSet *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::RSet const & type is null", 0);
    return 0;
  } 
  arg4 = (int)jarg4; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESet((Xapian::ESet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetESet__SWIG_3(void * jarg1, unsigned int jarg2, void * jarg3) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::RSet *arg3 = 0 ;
  Xapian::ESet result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::RSet *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::RSet const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_eset(arg2,(Xapian::RSet const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::ESet((Xapian::ESet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMatchingTermsBegin__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::docid arg2 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_matching_terms_begin(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMatchingTermsEnd__SWIG_0(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::docid arg2 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_matching_terms_end(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMatchingTermsBegin__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_matching_terms_begin((Xapian::MSetIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Enquire_GetMatchingTermsEnd__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  Xapian::MSetIterator *arg2 = 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  arg2 = (Xapian::MSetIterator *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::MSetIterator const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_matching_terms_end((Xapian::MSetIterator const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_RegisterMatchDecider__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::MatchDecider *arg3 = (Xapian::MatchDecider *) 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::MatchDecider *)jarg3; 
  {
    try {
      (arg1)->register_match_decider((std::string const &)*arg2,(Xapian::MatchDecider const *)arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Enquire_RegisterMatchDecider__SWIG_1(void * jarg1, char * jarg2) {
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->register_match_decider((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Enquire_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::Enquire *arg1 = (Xapian::Enquire *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Enquire *)jarg1; 
  {
    try {
      result = ((Xapian::Enquire const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Weight(void * jarg1) {
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  
  arg1 = (Xapian::Weight *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Weight_Name(void * jarg1) {
  char * jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  {
    try {
      result = ((Xapian::Weight const *)arg1)->name();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Weight_Serialise(void * jarg1) {
  char * jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  {
    try {
      result = ((Xapian::Weight const *)arg1)->serialise();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Weight_Unserialise(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::Weight *result = 0 ;
  
  arg1 = (Xapian::Weight *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (Xapian::Weight *)((Xapian::Weight const *)arg1)->unserialise((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Weight_GetSumPart(void * jarg1, unsigned int jarg2, double jarg3) {
  double jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::doclength arg3 ;
  Xapian::weight result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::doclength)jarg3; 
  {
    try {
      result = (Xapian::weight)((Xapian::Weight const *)arg1)->get_sumpart(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Weight_GetMaxPart(void * jarg1) {
  double jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::Weight const *)arg1)->get_maxpart();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Weight_GetSumExtra(void * jarg1, double jarg2) {
  double jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  Xapian::doclength arg2 ;
  Xapian::weight result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  arg2 = (Xapian::doclength)jarg2; 
  {
    try {
      result = (Xapian::weight)((Xapian::Weight const *)arg1)->get_sumextra(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Weight_GetMaxExtra(void * jarg1) {
  double jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::Weight const *)arg1)->get_maxextra();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Weight_GetSumPartNeedsDocLength(void * jarg1) {
  unsigned int jresult ;
  Xapian::Weight *arg1 = (Xapian::Weight *) 0 ;
  bool result;
  
  arg1 = (Xapian::Weight *)jarg1; 
  {
    try {
      result = (bool)((Xapian::Weight const *)arg1)->get_sumpart_needs_doclength();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_BoolWeight_Clone(void * jarg1) {
  void * jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  Xapian::BoolWeight *result = 0 ;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      result = (Xapian::BoolWeight *)((Xapian::BoolWeight const *)arg1)->clone();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_BoolWeight() {
  void * jresult ;
  Xapian::BoolWeight *result = 0 ;
  
  {
    try {
      result = (Xapian::BoolWeight *)new Xapian::BoolWeight();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_BoolWeight(void * jarg1) {
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_BoolWeight_Name(void * jarg1) {
  char * jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      result = ((Xapian::BoolWeight const *)arg1)->name();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_BoolWeight_Serialise(void * jarg1) {
  char * jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      result = ((Xapian::BoolWeight const *)arg1)->serialise();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_BoolWeight_Unserialise(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::BoolWeight *result = 0 ;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (Xapian::BoolWeight *)((Xapian::BoolWeight const *)arg1)->unserialise((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BoolWeight_GetSumPart(void * jarg1, unsigned int jarg2, double jarg3) {
  double jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::doclength arg3 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::doclength)jarg3; 
  {
    try {
      result = (Xapian::weight)((Xapian::BoolWeight const *)arg1)->get_sumpart(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BoolWeight_GetMaxPart(void * jarg1) {
  double jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::BoolWeight const *)arg1)->get_maxpart();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BoolWeight_GetSumExtra(void * jarg1, double jarg2) {
  double jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  Xapian::doclength arg2 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  arg2 = (Xapian::doclength)jarg2; 
  {
    try {
      result = (Xapian::weight)((Xapian::BoolWeight const *)arg1)->get_sumextra(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BoolWeight_GetMaxExtra(void * jarg1) {
  double jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::BoolWeight const *)arg1)->get_maxextra();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_BoolWeight_GetSumPartNeedsDocLength(void * jarg1) {
  unsigned int jresult ;
  Xapian::BoolWeight *arg1 = (Xapian::BoolWeight *) 0 ;
  bool result;
  
  arg1 = (Xapian::BoolWeight *)jarg1; 
  {
    try {
      result = (bool)((Xapian::BoolWeight const *)arg1)->get_sumpart_needs_doclength();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_BM25Weight__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  Xapian::BM25Weight *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  arg5 = (double)jarg5; 
  {
    try {
      result = (Xapian::BM25Weight *)new Xapian::BM25Weight(arg1,arg2,arg3,arg4,arg5);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_BM25Weight__SWIG_1() {
  void * jresult ;
  Xapian::BM25Weight *result = 0 ;
  
  {
    try {
      result = (Xapian::BM25Weight *)new Xapian::BM25Weight();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_BM25Weight_Clone(void * jarg1) {
  void * jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  Xapian::BM25Weight *result = 0 ;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      result = (Xapian::BM25Weight *)((Xapian::BM25Weight const *)arg1)->clone();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_BM25Weight(void * jarg1) {
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_BM25Weight_Name(void * jarg1) {
  char * jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      result = ((Xapian::BM25Weight const *)arg1)->name();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_BM25Weight_Serialise(void * jarg1) {
  char * jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      result = ((Xapian::BM25Weight const *)arg1)->serialise();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_BM25Weight_Unserialise(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::BM25Weight *result = 0 ;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (Xapian::BM25Weight *)((Xapian::BM25Weight const *)arg1)->unserialise((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BM25Weight_GetSumPart(void * jarg1, unsigned int jarg2, double jarg3) {
  double jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::doclength arg3 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::doclength)jarg3; 
  {
    try {
      result = (Xapian::weight)((Xapian::BM25Weight const *)arg1)->get_sumpart(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BM25Weight_GetMaxPart(void * jarg1) {
  double jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::BM25Weight const *)arg1)->get_maxpart();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BM25Weight_GetSumExtra(void * jarg1, double jarg2) {
  double jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  Xapian::doclength arg2 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  arg2 = (Xapian::doclength)jarg2; 
  {
    try {
      result = (Xapian::weight)((Xapian::BM25Weight const *)arg1)->get_sumextra(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_BM25Weight_GetMaxExtra(void * jarg1) {
  double jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::BM25Weight const *)arg1)->get_maxextra();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_BM25Weight_GetSumPartNeedsDocLength(void * jarg1) {
  unsigned int jresult ;
  Xapian::BM25Weight *arg1 = (Xapian::BM25Weight *) 0 ;
  bool result;
  
  arg1 = (Xapian::BM25Weight *)jarg1; 
  {
    try {
      result = (bool)((Xapian::BM25Weight const *)arg1)->get_sumpart_needs_doclength();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_TradWeight__SWIG_0(double jarg1) {
  void * jresult ;
  double arg1 ;
  Xapian::TradWeight *result = 0 ;
  
  arg1 = (double)jarg1; 
  {
    try {
      result = (Xapian::TradWeight *)new Xapian::TradWeight(arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_TradWeight__SWIG_1() {
  void * jresult ;
  Xapian::TradWeight *result = 0 ;
  
  {
    try {
      result = (Xapian::TradWeight *)new Xapian::TradWeight();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_TradWeight_Clone(void * jarg1) {
  void * jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  Xapian::TradWeight *result = 0 ;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      result = (Xapian::TradWeight *)((Xapian::TradWeight const *)arg1)->clone();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_TradWeight(void * jarg1) {
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_TradWeight_Name(void * jarg1) {
  char * jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      result = ((Xapian::TradWeight const *)arg1)->name();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_TradWeight_Serialise(void * jarg1) {
  char * jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  std::string result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      result = ((Xapian::TradWeight const *)arg1)->serialise();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_TradWeight_Unserialise(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::TradWeight *result = 0 ;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (Xapian::TradWeight *)((Xapian::TradWeight const *)arg1)->unserialise((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_TradWeight_GetSumPart(void * jarg1, unsigned int jarg2, double jarg3) {
  double jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  Xapian::termcount arg2 ;
  Xapian::doclength arg3 ;
  Xapian::weight result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::doclength)jarg3; 
  {
    try {
      result = (Xapian::weight)((Xapian::TradWeight const *)arg1)->get_sumpart(arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_TradWeight_GetMaxPart(void * jarg1) {
  double jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::TradWeight const *)arg1)->get_maxpart();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_TradWeight_GetSumExtra(void * jarg1, double jarg2) {
  double jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  Xapian::doclength arg2 ;
  Xapian::weight result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  arg2 = (Xapian::doclength)jarg2; 
  {
    try {
      result = (Xapian::weight)((Xapian::TradWeight const *)arg1)->get_sumextra(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_TradWeight_GetMaxExtra(void * jarg1) {
  double jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  Xapian::weight result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      result = (Xapian::weight)((Xapian::TradWeight const *)arg1)->get_maxextra();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_TradWeight_GetSumPartNeedsDocLength(void * jarg1) {
  unsigned int jresult ;
  Xapian::TradWeight *arg1 = (Xapian::TradWeight *) 0 ;
  bool result;
  
  arg1 = (Xapian::TradWeight *)jarg1; 
  {
    try {
      result = (bool)((Xapian::TradWeight const *)arg1)->get_sumpart_needs_doclength();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Database_AddDatabase(void * jarg1, void * jarg2) {
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::Database *arg2 = 0 ;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::Database *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Database const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->add_database((Xapian::Database const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Database__SWIG_0() {
  void * jresult ;
  Xapian::Database *result = 0 ;
  
  {
    try {
      result = (Xapian::Database *)new Xapian::Database();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Database__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Database *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (Xapian::Database *)new Xapian::Database((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Database(void * jarg1) {
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Database__SWIG_2(void * jarg1) {
  void * jresult ;
  Xapian::Database *arg1 = 0 ;
  Xapian::Database *result = 0 ;
  
  arg1 = (Xapian::Database *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Database const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Database *)new Xapian::Database((Xapian::Database const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Database_Reopen(void * jarg1) {
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      (arg1)->reopen();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Database_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_PostListBegin(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::PostingIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->postlist_begin((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PostingIterator((Xapian::PostingIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_PostListEnd(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::PostingIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->postlist_end((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PostingIterator((Xapian::PostingIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_TermListBegin(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->termlist_begin(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_TermListEnd(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->termlist_end(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_PositionListBegin(void * jarg1, unsigned int jarg2, char * jarg3) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  std::string *arg3 = 0 ;
  Xapian::PositionIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->positionlist_begin(arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PositionIterator((Xapian::PositionIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_PositionListEnd(void * jarg1, unsigned int jarg2, char * jarg3) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  std::string *arg3 = 0 ;
  Xapian::PositionIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->positionlist_end(arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::PositionIterator((Xapian::PositionIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_AllTermsBegin(void * jarg1) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->allterms_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_AllTermsEnd(void * jarg1) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      result = ((Xapian::Database const *)arg1)->allterms_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Database_GetDocCount(void * jarg1) {
  unsigned int jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      result = (Xapian::doccount)((Xapian::Database const *)arg1)->get_doccount();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Database_GetLastDocId(void * jarg1) {
  unsigned int jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid result;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      result = (Xapian::docid)((Xapian::Database const *)arg1)->get_lastdocid();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Database_GetAvLength(void * jarg1) {
  double jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::doclength result;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      result = (Xapian::doclength)((Xapian::Database const *)arg1)->get_avlength();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Database_GetTermFreq(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::doccount result;
  
  arg1 = (Xapian::Database *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (Xapian::doccount)((Xapian::Database const *)arg1)->get_termfreq((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Database_TermExists(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::Database *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (bool)((Xapian::Database const *)arg1)->term_exists((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Database_GetCollectionFreq(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::Database *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (Xapian::termcount)((Xapian::Database const *)arg1)->get_collection_freq((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Database_GetDocLength(void * jarg1, unsigned int jarg2) {
  double jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  Xapian::doclength result;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = (Xapian::doclength)((Xapian::Database const *)arg1)->get_doclength(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Database_KeepAlive(void * jarg1) {
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  
  arg1 = (Xapian::Database *)jarg1; 
  {
    try {
      (arg1)->keep_alive();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Database_GetDocument(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  Xapian::Database *arg1 = (Xapian::Database *) 0 ;
  Xapian::docid arg2 ;
  Xapian::Document result;
  
  arg1 = (Xapian::Database *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      result = (arg1)->get_document(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Document((Xapian::Document &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_WritableDatabase(void * jarg1) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_WritableDatabase__SWIG_0() {
  void * jresult ;
  Xapian::WritableDatabase *result = 0 ;
  
  {
    try {
      result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_WritableDatabase__SWIG_1(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  Xapian::WritableDatabase *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_WritableDatabase__SWIG_2(void * jarg1) {
  void * jresult ;
  Xapian::WritableDatabase *arg1 = 0 ;
  Xapian::WritableDatabase *result = 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::WritableDatabase const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::WritableDatabase *)new Xapian::WritableDatabase((Xapian::WritableDatabase const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_Flush(void * jarg1) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  {
    try {
      (arg1)->flush();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_BeginTransaction__SWIG_0(void * jarg1, unsigned int jarg2) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  bool arg2 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      (arg1)->begin_transaction(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_BeginTransaction__SWIG_1(void * jarg1) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  {
    try {
      (arg1)->begin_transaction();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_CommitTransaction(void * jarg1) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  {
    try {
      (arg1)->commit_transaction();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_CancelTransaction(void * jarg1) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  {
    try {
      (arg1)->cancel_transaction();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_WritableDatabase_AddDocument(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::Document *arg2 = 0 ;
  Xapian::docid result;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  arg2 = (Xapian::Document *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Document const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::docid)(arg1)->add_document((Xapian::Document const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_DeleteDocument__SWIG_0(void * jarg1, unsigned int jarg2) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::docid arg2 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  {
    try {
      (arg1)->delete_document(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_ReplaceDocument__SWIG_0(void * jarg1, unsigned int jarg2, void * jarg3) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  Xapian::docid arg2 ;
  Xapian::Document *arg3 = 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  arg2 = (Xapian::docid)jarg2; 
  arg3 = (Xapian::Document *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Document const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->replace_document(arg2,(Xapian::Document const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_WritableDatabase_DeleteDocument__SWIG_1(void * jarg1, char * jarg2) {
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      (arg1)->delete_document((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_WritableDatabase_ReplaceDocument__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::Document *arg3 = 0 ;
  Xapian::docid result;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::Document *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Document const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::docid)(arg1)->replace_document((std::string const &)*arg2,(Xapian::Document const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_WritableDatabase_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::WritableDatabase *arg1 = (Xapian::WritableDatabase *) 0 ;
  std::string result;
  
  arg1 = (Xapian::WritableDatabase *)jarg1; 
  {
    try {
      result = ((Xapian::WritableDatabase const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DB_CREATE_OR_OPEN_get() {
  int jresult ;
  int result;
  
  result = (int) 1;
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DB_CREATE_get() {
  int jresult ;
  int result;
  
  result = (int) 2;
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DB_CREATE_OR_OVERWRITE_get() {
  int jresult ;
  int result;
  
  result = (int) 3;
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DB_OPEN_get() {
  int jresult ;
  int result;
  
  result = (int) 4;
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Auto_Open__SWIG_0(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = Xapian::Auto::open((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Auto_Open__SWIG_1(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  {
    try {
      result = Xapian::Auto::open((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Auto_OpenStub(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = Xapian::Auto::open_stub((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Quartz_Open__SWIG_0(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = Xapian::Quartz::open((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Quartz_Open__SWIG_1(char * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      result = Xapian::Quartz::open((std::string const &)*arg1,arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Quartz_Open__SWIG_2(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  {
    try {
      result = Xapian::Quartz::open((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Flint_Open__SWIG_0(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = Xapian::Flint::open((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Flint_Open__SWIG_1(char * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      result = Xapian::Flint::open((std::string const &)*arg1,arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Flint_Open__SWIG_2(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  {
    try {
      result = Xapian::Flint::open((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_InMemory_Open() {
  void * jresult ;
  Xapian::WritableDatabase result;
  
  {
    try {
      result = Xapian::InMemory::open();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDa__SWIG_0(char * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      result = Xapian::Muscat36::open_da((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDa__SWIG_1(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = Xapian::Muscat36::open_da((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDa__SWIG_2(char * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      result = Xapian::Muscat36::open_da((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDa__SWIG_3(char * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      result = Xapian::Muscat36::open_da((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDb__SWIG_0(char * jarg1, unsigned long jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  size_t arg2 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = Xapian::Muscat36::open_db((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDb__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = Xapian::Muscat36::open_db((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDb__SWIG_2(char * jarg1, char * jarg2, unsigned long jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  size_t arg3 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (size_t)jarg3; 
  {
    try {
      result = Xapian::Muscat36::open_db((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Muscat36_OpenDb__SWIG_3(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = Xapian::Muscat36::open_db((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_Open__SWIG_0(char * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  Xapian::timeout arg3 ;
  Xapian::timeout arg4 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (unsigned int)jarg2; 
  arg3 = (Xapian::timeout)jarg3; 
  arg4 = (Xapian::timeout)jarg4; 
  {
    try {
      result = Xapian::Remote::open((std::string const &)*arg1,arg2,arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_Open__SWIG_1(char * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  Xapian::timeout arg3 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (unsigned int)jarg2; 
  arg3 = (Xapian::timeout)jarg3; 
  {
    try {
      result = Xapian::Remote::open((std::string const &)*arg1,arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_Open__SWIG_2(char * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (unsigned int)jarg2; 
  {
    try {
      result = Xapian::Remote::open((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_OpenWritable__SWIG_0(char * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  Xapian::timeout arg3 ;
  Xapian::timeout arg4 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (unsigned int)jarg2; 
  arg3 = (Xapian::timeout)jarg3; 
  arg4 = (Xapian::timeout)jarg4; 
  {
    try {
      result = Xapian::Remote::open_writable((std::string const &)*arg1,arg2,arg3,arg4);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_OpenWritable__SWIG_1(char * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  Xapian::timeout arg3 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (unsigned int)jarg2; 
  arg3 = (Xapian::timeout)jarg3; 
  {
    try {
      result = Xapian::Remote::open_writable((std::string const &)*arg1,arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_OpenWritable__SWIG_2(char * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  unsigned int arg2 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (unsigned int)jarg2; 
  {
    try {
      result = Xapian::Remote::open_writable((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_Open__SWIG_3(char * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Xapian::timeout arg3 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::timeout)jarg3; 
  {
    try {
      result = Xapian::Remote::open((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_Open__SWIG_4(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Xapian::Database result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = Xapian::Remote::open((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Database((Xapian::Database &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_OpenWritable__SWIG_3(char * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Xapian::timeout arg3 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (Xapian::timeout)jarg3; 
  {
    try {
      result = Xapian::Remote::open_writable((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Remote_OpenWritable__SWIG_4(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Xapian::WritableDatabase result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = Xapian::Remote::open_writable((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::WritableDatabase((Xapian::WritableDatabase &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_0(char * jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::termcount arg2 ;
  Xapian::termpos arg3 ;
  Xapian::Query *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Xapian::termcount)jarg2; 
  arg3 = (Xapian::termpos)jarg3; 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query((std::string const &)*arg1,arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_1(char * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::termcount arg2 ;
  Xapian::Query *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (Xapian::termcount)jarg2; 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query((std::string const &)*arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_2(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Query *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_3(int jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  Xapian::Query *arg2 = 0 ;
  Xapian::Query *arg3 = 0 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  arg2 = (Xapian::Query *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Query const & type is null", 0);
    return 0;
  } 
  arg3 = (Xapian::Query *)jarg3;
  if(!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Query const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query(arg1,(Xapian::Query const &)*arg2,(Xapian::Query const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_4(int jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_5(void * jarg1) {
  void * jresult ;
  Xapian::Query *arg1 = 0 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query *)jarg1;
  if(!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Query const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query((Xapian::Query const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_6(int jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  std::vector<std::string > *arg2 = 0 ;
  Xapian::termcount arg3 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  arg2 = (std::vector<std::string > *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector<std::string > const & type is null", 0);
    return 0;
  } 
  arg3 = (Xapian::termcount)jarg3; 
  {
    try {
      result = (Xapian::Query *)new_Xapian_Query__SWIG_6(arg1,(std::vector<std::string > const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_7(int jarg1, void * jarg2) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  std::vector<std::string > *arg2 = 0 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  arg2 = (std::vector<std::string > *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector<std::string > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Query *)new_Xapian_Query__SWIG_6(arg1,(std::vector<std::string > const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_8(int jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  std::vector<Xapian::Query > *arg2 = 0 ;
  Xapian::termcount arg3 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  arg2 = (std::vector<Xapian::Query > *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector<Xapian::Query > const & type is null", 0);
    return 0;
  } 
  arg3 = (Xapian::termcount)jarg3; 
  {
    try {
      result = (Xapian::Query *)new_Xapian_Query__SWIG_8(arg1,(std::vector<Xapian::Query > const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_9(int jarg1, void * jarg2) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  std::vector<Xapian::Query > *arg2 = 0 ;
  Xapian::Query *result = 0 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  arg2 = (std::vector<Xapian::Query > *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector<Xapian::Query > const & type is null", 0);
    return 0;
  } 
  {
    try {
      result = (Xapian::Query *)new_Xapian_Query__SWIG_8(arg1,(std::vector<Xapian::Query > const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_10(int jarg1, void * jarg2) {
  void * jresult ;
  Xapian::Query::op arg1 ;
  Xapian::Query arg2 ;
  Xapian::Query *result = 0 ;
  Xapian::Query *argp2 ;
  
  arg1 = (Xapian::Query::op)jarg1; 
  argp2 = (Xapian::Query *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Xapian::Query", 0);
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (Xapian::Query *)new Xapian::Query(arg1,arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Query__SWIG_11() {
  void * jresult ;
  Xapian::Query *result = 0 ;
  
  {
    try {
      result = (Xapian::Query *)new Xapian::Query();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Query(void * jarg1) {
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Query_GetLength(void * jarg1) {
  unsigned int jresult ;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  Xapian::termcount result;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      result = (Xapian::termcount)((Xapian::Query const *)arg1)->get_length();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Query_GetTermsBegin(void * jarg1) {
  void * jresult ;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      result = ((Xapian::Query const *)arg1)->get_terms_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Query_GetTermsEnd(void * jarg1) {
  void * jresult ;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      result = ((Xapian::Query const *)arg1)->get_terms_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Query_Empty(void * jarg1) {
  unsigned int jresult ;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  bool result;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      result = (bool)((Xapian::Query const *)arg1)->empty();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Query_IsEmpty(void * jarg1) {
  unsigned int jresult ;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  bool result;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      result = (bool)((Xapian::Query const *)arg1)->is_empty();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Query_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::Query *arg1 = (Xapian::Query *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Query *)jarg1; 
  {
    try {
      result = (arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Stopper_Apply(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::Stopper *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (bool)((Xapian::Stopper const *)arg1)->operator ()((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Stopper(void * jarg1) {
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  
  arg1 = (Xapian::Stopper *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Stopper_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Stopper *)jarg1; 
  {
    try {
      result = ((Xapian::Stopper const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Stopper_GetDescriptionSwigExplicitStopper(void * jarg1) {
  char * jresult ;
  Xapian::Stopper *arg1 = (Xapian::Stopper *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Stopper *)jarg1; 
  {
    try {
      result = ((Xapian::Stopper const *)arg1)->Xapian::Stopper::get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Stopper() {
  void * jresult ;
  Xapian::Stopper *result = 0 ;
  
  {
    try {
      result = (Xapian::Stopper *)new SwigDirector_Stopper();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Stopper_director_connect(void *objarg, SwigDirector_Stopper::SWIG_Callback0_t callback0, SwigDirector_Stopper::SWIG_Callback1_t callback1) {
  Xapian::Stopper *obj = (Xapian::Stopper *)objarg;
  SwigDirector_Stopper *director = dynamic_cast<SwigDirector_Stopper *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_SimpleStopper() {
  void * jresult ;
  Xapian::SimpleStopper *result = 0 ;
  
  {
    try {
      result = (Xapian::SimpleStopper *)new Xapian::SimpleStopper();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_SimpleStopper_Add(void * jarg1, char * jarg2) {
  Xapian::SimpleStopper *arg1 = (Xapian::SimpleStopper *) 0 ;
  std::string arg2 ;
  
  arg1 = (Xapian::SimpleStopper *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  arg2 = std::string(jarg2); 
  {
    try {
      (arg1)->add(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_SimpleStopper_Apply(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  Xapian::SimpleStopper *arg1 = (Xapian::SimpleStopper *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (Xapian::SimpleStopper *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (bool)((Xapian::SimpleStopper const *)arg1)->operator ()((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SimpleStopper(void * jarg1) {
  Xapian::SimpleStopper *arg1 = (Xapian::SimpleStopper *) 0 ;
  
  arg1 = (Xapian::SimpleStopper *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_SimpleStopper_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::SimpleStopper *arg1 = (Xapian::SimpleStopper *) 0 ;
  std::string result;
  
  arg1 = (Xapian::SimpleStopper *)jarg1; 
  {
    try {
      result = ((Xapian::SimpleStopper const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_QueryParser() {
  void * jresult ;
  Xapian::QueryParser *result = 0 ;
  
  {
    try {
      result = (Xapian::QueryParser *)new Xapian::QueryParser();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_QueryParser(void * jarg1) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_SetStemmer(void * jarg1, void * jarg2) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Stem *arg2 = 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  arg2 = (Xapian::Stem *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Stem const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->set_stemmer((Xapian::Stem const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_SetStemmingStrategy(void * jarg1, int jarg2) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::QueryParser::stem_strategy arg2 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  arg2 = (Xapian::QueryParser::stem_strategy)jarg2; 
  {
    try {
      (arg1)->set_stemming_strategy(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_SetStopper__SWIG_0(void * jarg1, void * jarg2) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Stopper *arg2 = (Xapian::Stopper *) 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  arg2 = (Xapian::Stopper *)jarg2; 
  {
    try {
      (arg1)->set_stopper(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_SetStopper__SWIG_1(void * jarg1) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  {
    try {
      (arg1)->set_stopper();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_SetDefaultOp(void * jarg1, int jarg2) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Query::op arg2 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  arg2 = (Xapian::Query::op)jarg2; 
  {
    try {
      (arg1)->set_default_op(arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_QueryParser_GetDefaultOp(void * jarg1) {
  int jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Query::op result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  {
    try {
      result = (Xapian::Query::op)((Xapian::QueryParser const *)arg1)->get_default_op();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_SetDatabase(void * jarg1, void * jarg2) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::Database *arg2 = 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  arg2 = (Xapian::Database *)jarg2;
  if(!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Xapian::Database const & type is null", 0);
    return ;
  } 
  {
    try {
      (arg1)->set_database((Xapian::Database const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QueryParser_ParseQuery__SWIG_0(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::Query result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (arg1)->parse_query((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Query((Xapian::Query &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QueryParser_ParseQuery__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string *arg2 = 0 ;
  unsigned int arg3 ;
  Xapian::Query result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (unsigned int)jarg3; 
  {
    try {
      result = (arg1)->parse_query((std::string const &)*arg2,arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::Query((Xapian::Query &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_AddPrefix(void * jarg1, char * jarg2, char * jarg3) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      (arg1)->add_prefix((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_QueryParser_AddBooleanPrefix(void * jarg1, char * jarg2, char * jarg3) {
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  {
    try {
      (arg1)->add_boolean_prefix((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QueryParser_StopListBegin(void * jarg1) {
  void * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  {
    try {
      result = ((Xapian::QueryParser const *)arg1)->stoplist_begin();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QueryParser_StopListEnd(void * jarg1) {
  void * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  {
    try {
      result = ((Xapian::QueryParser const *)arg1)->stoplist_end();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QueryParser_UnstemBegin(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = ((Xapian::QueryParser const *)arg1)->unstem_begin((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_QueryParser_UnstemEnd(void * jarg1, char * jarg2) {
  void * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string *arg2 = 0 ;
  Xapian::TermIterator result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = ((Xapian::QueryParser const *)arg1)->unstem_end((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = new Xapian::TermIterator((Xapian::TermIterator &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_QueryParser_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::QueryParser *arg1 = (Xapian::QueryParser *) 0 ;
  std::string result;
  
  arg1 = (Xapian::QueryParser *)jarg1; 
  {
    try {
      result = ((Xapian::QueryParser const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Stem(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  Xapian::Stem *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    try {
      result = (Xapian::Stem *)new Xapian::Stem((std::string const &)*arg1);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Stem(void * jarg1) {
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  
  arg1 = (Xapian::Stem *)jarg1; 
  {
    try {
      delete arg1;
      
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Stem_Apply(void * jarg1, char * jarg2) {
  char * jresult ;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  std::string *arg2 = 0 ;
  std::string result;
  
  arg1 = (Xapian::Stem *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = ((Xapian::Stem const *)arg1)->operator ()((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Stem_StemWord(void * jarg1, char * jarg2) {
  char * jresult ;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  std::string *arg2 = 0 ;
  std::string result;
  
  arg1 = (Xapian::Stem *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  {
    try {
      result = (arg1)->stem_word((std::string const &)*arg2);
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Stem_GetDescription(void * jarg1) {
  char * jresult ;
  Xapian::Stem *arg1 = (Xapian::Stem *) 0 ;
  std::string result;
  
  arg1 = (Xapian::Stem *)jarg1; 
  {
    try {
      result = ((Xapian::Stem const *)arg1)->get_description();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Stem_GetAvailableLanguages() {
  char * jresult ;
  std::string result;
  
  {
    try {
      result = Xapian::Stem::get_available_languages();
    } catch (...) {
      string msg;
      int code = XapianExceptionHandler(msg);
      
      
      
      
      
      
      
      
      
      
      XapianException(code, msg);
    }
  }
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT Xapian::Weight * SWIGSTDCALL CSharp_BoolWeightUpcast(Xapian::BoolWeight *objectRef) {
    return (Xapian::Weight *)objectRef;
}

SWIGEXPORT Xapian::Weight * SWIGSTDCALL CSharp_BM25WeightUpcast(Xapian::BM25Weight *objectRef) {
    return (Xapian::Weight *)objectRef;
}

SWIGEXPORT Xapian::Weight * SWIGSTDCALL CSharp_TradWeightUpcast(Xapian::TradWeight *objectRef) {
    return (Xapian::Weight *)objectRef;
}

SWIGEXPORT Xapian::Database * SWIGSTDCALL CSharp_WritableDatabaseUpcast(Xapian::WritableDatabase *objectRef) {
    return (Xapian::Database *)objectRef;
}

SWIGEXPORT Xapian::Stopper * SWIGSTDCALL CSharp_SimpleStopperUpcast(Xapian::SimpleStopper *objectRef) {
    return (Xapian::Stopper *)objectRef;
}

#ifdef __cplusplus
}
#endif


Generated by  Doxygen 1.6.0   Back to index