trunk/ruby/HyperEstraier_wrap.cxx

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.24
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */


#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


#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
#  if defined(__SUNPRO_CC) 
#    define SWIG_TEMPLATE_DISAMBIGUATOR template
#  else
#    define SWIG_TEMPLATE_DISAMBIGUATOR 
#  endif
#endif

/* ruby.swg */
/* Implementation : RUBY */
#define SWIGRUBY 1

#include "ruby.h"

/* Flags for pointer conversion */
#define SWIG_POINTER_EXCEPTION     0x1
#define SWIG_POINTER_DISOWN        0x2

#define NUM2USHRT(n) (\
    (0 <= NUM2UINT(n) && NUM2UINT(n) <= USHRT_MAX)\
    ? (unsigned short) NUM2UINT(n) \
    : (rb_raise(rb_eArgError, "integer %d out of range of `unsigned short'",\
               NUM2UINT(n)), (short)0)\
)

#define NUM2SHRT(n) (\
    (SHRT_MIN <= NUM2INT(n) && NUM2INT(n) <= SHRT_MAX)\
    ? (short)NUM2INT(n)\
    : (rb_raise(rb_eArgError, "integer %d out of range of `short'",\
               NUM2INT(n)), (short)0)\
)

/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
#ifndef NUM2LL
#define NUM2LL(x) NUM2LONG((x))
#endif
#ifndef LL2NUM
#define LL2NUM(x) INT2NUM((long) (x))
#endif
#ifndef ULL2NUM
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
#endif

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
#ifndef NUM2ULL
#ifdef HAVE_LONG_LONG
#define NUM2ULL(x) rb_num2ull((x))
#else
#define NUM2ULL(x) NUM2ULONG(x)
#endif
#endif

/*
 * Need to be very careful about how these macros are defined, especially
 * when compiling C++ code or C code with an ANSI C compiler.
 *
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
 * a Ruby method so that it can be passed as an argument to API functions
 * like rb_define_method() and rb_define_singleton_method().
 *
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
 * can be passed as an argument to API functions like Data_Wrap_Struct()
 * and Data_Make_Struct().
 */
 
#ifdef __cplusplus
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
#    define PROTECTFUNC(f) ((VALUE (*)()) f)
#    define VALUEFUNC(f) ((VALUE (*)()) f)
#    define VOIDFUNC(f)  ((void (*)()) f)
#  else
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
#      define PROTECTFUNC(f) ((VALUE (*)()) f)
#      define VALUEFUNC(f) ((VALUE (*)()) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    else /* These definitions should work for Ruby 1.7+ */
#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    endif
#  endif
#else
#  define VALUEFUNC(f) (f)
#  define VOIDFUNC(f) (f)
#endif

typedef struct {
  VALUE klass;
  VALUE mImpl;
  void  (*mark)(void *);
  void  (*destroy)(void *);
} swig_class;

/* Don't use for expressions have side effect */
#ifndef RB_STRING_VALUE
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#endif
#ifndef StringValue
#define StringValue(s) RB_STRING_VALUE(s)
#endif
#ifndef StringValuePtr
#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr
#endif
#ifndef StringValueLen
#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len
#endif
#ifndef SafeStringValue
#define SafeStringValue(v) do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)
#endif

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
#endif

/* Contract support */

#define SWIG_contract_assert(expr, msg) if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else


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

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

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

#include <string.h>

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

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the swig runtime code.
  In 99.9% of the cases, swig just needs to declare them as 'static'.
  
  But only do this if is strictly necessary, ie, if you have problems
  with your compiler or so.
*/
#ifndef SWIGRUNTIME
#define SWIGRUNTIME static
#endif
#ifndef SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct swig_type_info {
  const char             *name;
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

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

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

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

/*
  Register a type mapping with the type-checking
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = *tl;
  while (tc) {
    /* check simple type equivalence */
    int typeequiv = (strcmp(tc->name, ti->name) == 0);   
    /* check full type equivalence, resolving typedefs */
    if (!typeequiv) {
      /* only if tc is not a typedef (no '|' on it) */
      if (tc->str && ti->str && !strstr(tc->str,"|")) {
        typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
      }
    }
    if (typeequiv) {
      /* Already exists in the table.  Just add additional types to the list */
      if (ti->clientdata) tc->clientdata = ti->clientdata;
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = *tl;
  *tl = ti;

  /* Build linked lists */
  l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;
  head->next = next;

  return ret;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
        s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

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

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

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

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
  Search for a swig_type_info structure
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
  swig_type_info *ty = tl;
  while (ty) {
    if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* 
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata) return;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = tl;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0))
          SWIG_TypeClientDataTL(tl,tc,clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

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

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

/*
  This function will propagate the clientdata field of type to any new
  swig_type_info structures that have been added into the list of
  equivalent types.  It is like calling SWIG_TypeClientData(type,
  clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
  swig_type_info *equiv = type->next;
  swig_type_info *tc;
  if (!type->clientdata) return;
  while (equiv) {
    if (!equiv->converter) {
      tc = tl;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
          SWIG_TypeClientDataTL(tl,tc, type->clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

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

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

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

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

#ifdef __cplusplus
}
#endif

/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/


#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  if !defined(STATIC_LINKED)
#    define SWIGEXPORT(a) __declspec(dllexport) a
#  else
#    define SWIGEXPORT(a) a
#  endif
#else
#  define SWIGEXPORT(a) a
#endif

#ifdef __cplusplus
extern "C" {
#endif


/*************************************************************************/


/* The static type info list */

static swig_type_info *swig_type_list = 0;
static swig_type_info **swig_type_list_handle = &swig_type_list;
  

/* Register a type mapping with the type-checking */
static swig_type_info *
SWIG_TypeRegister(swig_type_info *ti) {
  return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
}

/* Search for a swig_type_info structure */
static swig_type_info *
SWIG_TypeQuery(const char *name) {
  return SWIG_TypeQueryTL(*swig_type_list_handle, name);
}

/* Set the clientdata field for a type */
static void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
static void
SWIG_PropagateClientData(swig_type_info *type) {
  SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
}

#ifdef __cplusplus
}
#endif

/* Common SWIG API */
#define SWIG_ConvertPtr(obj, pp, type, flags) \
  SWIG_Ruby_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags) \
  SWIG_Ruby_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags) \
  SWIG_Ruby_MustGetPtr(p, type, argnum, flags)

/* Ruby-specific SWIG API */

#define SWIG_InitRuntime() \
  SWIG_Ruby_InitRuntime()
#define SWIG_define_class(ty) \
  SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty) \
  SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value) \
  SWIG_Ruby_MangleStr(value)
#define SWIG_CheckConvert(value, ty) \
  SWIG_Ruby_CheckConvert(value, ty)
#define SWIG_NewPackedObj(ptr, sz, ty) \
  SWIG_Ruby_NewPackedObj(ptr, sz, ty)
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
  SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)

/* rubydef.swg */
#ifdef __cplusplus
extern "C" {
#endif

static VALUE _mSWIG = Qnil;
static VALUE _cSWIG_Pointer = Qnil;
static VALUE swig_runtime_data_type_pointer = Qnil;

/* Initialize Ruby runtime support */
static void
SWIG_Ruby_InitRuntime(void)
{
    VALUE pointer;
    
    if (_mSWIG == Qnil) {
        _mSWIG = rb_define_module("SWIG");
    }
    
    /* first check if pointer already created */
    pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
    if (pointer != Qnil) {
      Data_Get_Struct(pointer, swig_type_info *, swig_type_list_handle);
    } else {
      /* register a new class */
      VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
      /* create and store the structure pointer to a global variable */
      swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, swig_type_list_handle);
      rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
    }
}

/* Define Ruby class for C type */
static void
SWIG_Ruby_define_class(swig_type_info *type)
{
    VALUE klass;
    char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    sprintf(klass_name, "TYPE%s", type->name);
    if (NIL_P(_cSWIG_Pointer)) {
        _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
        rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
    }
    klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
    free((void *) klass_name);
}

/* Create a new pointer object */
static VALUE
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own)
{
    char *klass_name;
    swig_class *sklass;
    VALUE klass;
    VALUE obj;
    
    if (!ptr)
        return Qnil;
    
    if (type->clientdata) {
      sklass = (swig_class *) type->clientdata;
      obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
    } else {
      klass_name = (char *) malloc(4 + strlen(type->name) + 1);
      sprintf(klass_name, "TYPE%s", type->name);
      klass = rb_const_get(_mSWIG, rb_intern(klass_name));
      free((void *) klass_name);
      obj = Data_Wrap_Struct(klass, 0, 0, ptr);
    }
    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
    return obj;
}

/* Create a new class instance (always owned) */
static VALUE
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
{
    VALUE obj;
    swig_class *sklass = (swig_class *) type->clientdata;
    obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
    return obj;
}

/* Get type mangle from class name */
static SWIGINLINE char *
SWIG_Ruby_MangleStr(VALUE obj)
{
  VALUE stype = rb_iv_get(obj, "__swigtype__");
  return StringValuePtr(stype);
}

/* Convert a pointer value */
static int
SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags)
{
  char *c;
  swig_type_info *tc;

  /* Grab the pointer */
  if (NIL_P(obj)) {
    *ptr = 0;
    return 0;
  } else {
    Data_Get_Struct(obj, void, *ptr);
  }
  
  /* Do type-checking if type info was provided */
  if (ty) {
    if (ty->clientdata) {
        if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
          if (*ptr == 0)
            rb_raise(rb_eRuntimeError, "This %s already released", ty->str);
          return 0;
        }
    }
    if ((c = SWIG_MangleStr(obj)) == NULL) {
      if (flags & SWIG_POINTER_EXCEPTION)
        rb_raise(rb_eTypeError, "Expected %s", ty->str);
      else
        return -1;
    }
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) {
      if (flags & SWIG_POINTER_EXCEPTION)
        rb_raise(rb_eTypeError, "Expected %s", ty->str);
      else
        return -1;
    }
    *ptr = SWIG_TypeCast(tc, *ptr);
  }
  return 0;
}

/* Convert a pointer value, signal an exception on a type mismatch */
static SWIGINLINE void *
SWIG_Ruby_MustGetPtr(VALUE obj, swig_type_info *ty, int argnum, int flags)
{
  void *result;
  SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
  return result;
}

/* Check convert */
static SWIGINLINE int
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
{
  char *c = SWIG_MangleStr(obj);
  if (!c)
    return 0;
  return SWIG_TypeCheck(c,ty) != 0;
}

static VALUE
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r, ptr, sz);
  strcpy(r, type->name);
  return rb_str_new2(result);
}

/* Convert a packed value value */
static void
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  const char  *c;

  if (TYPE(obj) != T_STRING) goto type_error;
  c = StringValuePtr(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c, ptr, sz);
  if (ty) {
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) goto type_error;
  }
  return;

type_error:

  if (flags) {
    if (ty) {
      rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name);
    } else {
      rb_raise(rb_eTypeError, "Expected a pointer");
    }
  }
}

#ifdef __cplusplus
}
#endif


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

#define  SWIGTYPE_p_estraier__Condition swig_types[0] 
#define  SWIGTYPE_p_ESTCOND swig_types[1] 
#define  SWIGTYPE_p_estraier__Database swig_types[2] 
#define  SWIGTYPE_p_unsigned_long swig_types[3] 
#define  SWIGTYPE_p_ESTDOC swig_types[4] 
#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[5] 
#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[6] 
#define  SWIGTYPE_p_std__vectorTint_t swig_types[7] 
#define  SWIGTYPE_p_estraier__Document swig_types[8] 
static swig_type_info *swig_types[10];

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

#define SWIG_init    Init_HyperEstraier
#define SWIG_name    "HyperEstraier"

static VALUE mHyperEstraier;

static void SWIG_AsVal(VALUE obj, int *val)
{
    *val = (int) NUM2INT(obj);
}


#define  SWIG_MemoryError    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_UnknownError  99


static void SWIG_exception_(int code, const char *msg) {
    switch (code) {
        case SWIG_MemoryError:
            rb_raise(rb_eNoMemError, msg);
            break;
        case SWIG_IOError:
            rb_raise(rb_eIOError, msg);
            break;
        case SWIG_RuntimeError:
            rb_raise(rb_eRuntimeError, msg);
            break;
        case SWIG_IndexError:
            rb_raise(rb_eIndexError, msg);
            break;
        case SWIG_TypeError:
            rb_raise(rb_eTypeError, msg);
            break;
        case SWIG_DivisionByZero:
            rb_raise(rb_eZeroDivError, msg);
            break;
        case SWIG_OverflowError:
            rb_raise(rb_eRangeError, msg);
            break;
        case SWIG_SyntaxError:
            rb_raise(rb_eSyntaxError, msg);
            break;
        case SWIG_ValueError:
            rb_raise(rb_eArgError, msg);
            break;
        case SWIG_SystemError:
            rb_raise(rb_eFatal, msg);
            break;
        case SWIG_UnknownError:
            rb_raise(rb_eRuntimeError, msg);
            break;
        default:
            break;
    }
}

#define SWIG_exception(a, b) SWIG_exception_((a), (b))


#include <stdexcept>


#include <string>

#define SWIG_FLOAT_P(x) ((TYPE(x) == T_FLOAT) || FIXNUM_P(x))

bool SWIG_BOOL_P(VALUE) {
    // dummy test, RTEST should take care of everything
    return true;
}
bool SWIG_RB2BOOL(VALUE x) {
    return RTEST(x);
}
VALUE SWIG_BOOL2RB(bool b) {
    return b ? Qtrue : Qfalse;
}
double SWIG_NUM2DBL(VALUE x) {
    return (FIXNUM_P(x) ? FIX2INT(x) : NUM2DBL(x));
}
bool SWIG_STRING_P(VALUE x) {
    return TYPE(x) == T_STRING;
}
std::string SWIG_RB2STR(VALUE x) {
    return std::string(StringValuePtr(x));
}
VALUE SWIG_STR2RB(const std::string& s) {
    return rb_str_new2(s.c_str());
}


#include <string>


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


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


#include <utility>

static std::string std_vector_Sl_std_string_Sg__pop(std::vector<std::string > *self){
                if (self->size() == 0)
                    throw std::out_of_range("pop from empty vector");
                std::string x = self->back();
                self->pop_back();
                return x;
            }
static std::string std_vector_Sl_std_string_Sg____getitem__(std::vector<std::string > *self,int i){
                int size = int(self->size());
                if (i<0) i += size;
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
static void std_vector_Sl_std_string_Sg____setitem__(std::vector<std::string > *self,int i,std::string x){
                int size = int(self->size());
                if (i<0) i+= size;
                if (i>=0 && i<size)
                    (*self)[i] = x;
                else
                    throw std::out_of_range("vector index out of range");
            }
static void std_vector_Sl_std_string_Sg__each(std::vector<std::string > *self){
                for (unsigned int i=0; i<self->size(); i++)
                    rb_yield(SWIG_STR2RB((*self)[i]));
            }

swig_class cStrVector;
static void free_std_vector_Sl_std_string_Sg_(std::vector<std::string > *);
static int std_vector_Sl_int_Sg__pop(std::vector<int > *self){
                if (self->size() == 0)
                    throw std::out_of_range("pop from empty vector");
                int x = self->back();
                self->pop_back();
                return x;
            }
static int std_vector_Sl_int_Sg____getitem__(std::vector<int > *self,int i){
                int size = int(self->size());
                if (i<0) i += size;
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
static void std_vector_Sl_int_Sg____setitem__(std::vector<int > *self,int i,int x){
                int size = int(self->size());
                if (i<0) i+= size;
                if (i>=0 && i<size)
                    (*self)[i] = x;
                else
                    throw std::out_of_range("vector index out of range");
            }
static void std_vector_Sl_int_Sg__each(std::vector<int > *self){
                for (unsigned int i=0; i<self->size(); i++)
                    rb_yield(INT2NUM((*self)[i]));
            }

swig_class cIntVector;
static void free_std_vector_Sl_int_Sg_(std::vector<int > *);
static std::string std_map_Sl_std_string_Sc_std_string_Sg____getitem__(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                if (i != self->end())
                    return i->second;
                else
                    throw std::out_of_range("key not found");
            }
static void std_map_Sl_std_string_Sc_std_string_Sg____setitem__(std::map<std::string,std::string > *self,std::string key,std::string x){
                (*self)[key] = x;
            }
static std::string std_map_Sl_std_string_Sc_std_string_Sg____delitem__(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                if (i != self->end()) {
                    std::string x = i->second;
                    self->erase(i);
                    return x;
                } else
                    throw std::out_of_range("key not found");
            }
static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map<std::string,std::string > *self,std::string key){
                std::map<std::string,std::string >::iterator i = self->find(key);
                return i != self->end();
            }
static VALUE std_map_Sl_std_string_Sc_std_string_Sg__keys(std::map<std::string,std::string > *self){
                VALUE keyList = rb_ary_new2(self->size());
                std::map<std::string,std::string >::iterator i;
                unsigned int j;
                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                    rb_ary_store(keyList,j,
                                 SWIG_STR2RB(i->first));
                }
                return keyList;
            }
static VALUE std_map_Sl_std_string_Sc_std_string_Sg__values(std::map<std::string,std::string > *self){
                VALUE valueList = rb_ary_new2(self->size());
                std::map<std::string,std::string >::iterator i;
                unsigned int j;
                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                    rb_ary_store(valueList,j,
                                 SWIG_STR2RB(i->second));
                }
                return valueList;
            }
static void std_map_Sl_std_string_Sc_std_string_Sg__each(std::map<std::string,std::string > *self){
                std::map<std::string,std::string >::iterator i;
                for (i=self->begin(); i!=self->end(); ++i) {
                    VALUE entry = rb_ary_new2(2);
                    rb_ary_store(entry,0,SWIG_STR2RB(i->first));
                    rb_ary_store(entry,1,SWIG_STR2RB(i->second));
                    rb_yield(entry);
                }
            }

swig_class cStrStrMap;
static void free_std_map_Sl_std_string_Sc_std_string_Sg_(std::map<std::string,std::string > *);

#include "HyperEstraierWrapper.cpp"


swig_class cCondition;
static void free_estraier_Condition(estraier::Condition *);

swig_class cDocument;
static void free_estraier_Document(estraier::Document *);

swig_class cDatabase;
static void free_estraier_Database(estraier::Database *);
static VALUE
_wrap_new_StrVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    std::vector<std::string > *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = NUM2UINT(argv[0]);
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE
_wrap_new_StrVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >();
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE
_wrap_new_StrVector__SWIG_2(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    std::string *arg2 = 0 ;
    std::vector<std::string > *result;
    std::string temp2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2UINT(argv[0]);
    {
        if (TYPE(argv[1]) == T_STRING) {
            temp2 = std::string(StringValuePtr(argv[1]));
            arg2 = &temp2;
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_StrVector_allocate(VALUE self) {
#else
    static VALUE
    _wrap_StrVector_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorTstd__string_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_StrVector__SWIG_3(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = 0 ;
    std::vector<std::string > *result;
    std::vector<std::string > temp1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp1 = std::vector<std::string >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (SWIG_STRING_P(o))
                temp1[i] = (std::string)(SWIG_RB2STR(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""std::string" ">)");
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
        }
    }
    {
        try {
            result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE _wrap_new_StrVector(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_StrVector__SWIG_1(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_StrVector__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            /* native sequence? */
            if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
                unsigned int size = RARRAY(argv[0])->len;
                if (size == 0) {
                    /* an empty sequence can be of any type */
                    _v = 1;
                } else {
                    /* check the first element only */
                    VALUE o = RARRAY(argv[0])->ptr[0];
                    if (SWIG_STRING_P(o))
                    _v = 1;
                    else
                    _v = 0;
                }
            } else {
                /* wrapped vector? */
                std::vector<std::string >* v;
                if (SWIG_ConvertPtr(argv[0],(void **) &v, 
                SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_StrVector__SWIG_3(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = (TYPE(argv[1]) == T_STRING) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_StrVector__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrVector'");
    return Qnil;
}


static VALUE
_wrap_StrVector___len__(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    unsigned int result;
    std::vector<std::string > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<std::string >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                if (SWIG_STRING_P(o))
                temp1[i] = (std::string)(SWIG_RB2STR(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""std::string" ">)");
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
        }
    }
    {
        try {
            result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_StrVector_emptyq___(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    bool result;
    std::vector<std::string > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<std::string >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                if (SWIG_STRING_P(o))
                temp1[i] = (std::string)(SWIG_RB2STR(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""std::string" ">)");
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
        }
    }
    {
        try {
            result = (bool)((std::vector<std::string > const *)arg1)->empty();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_StrVector_clear(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    {
        try {
            (arg1)->clear();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_StrVector_push(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    std::string arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            arg2 = std::string(StringValuePtr(argv[0]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            (arg1)->push_back(arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_StrVector_pop(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    {
        try {
            result = std_vector_Sl_std_string_Sg__pop(arg1);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_StrVector___getitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            result = std_vector_Sl_std_string_Sg____getitem__(arg1,arg2);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_StrVector___setitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    int arg2 ;
    std::string arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    arg2 = NUM2INT(argv[0]);
    {
        if (TYPE(argv[1]) == T_STRING) {
            arg3 = std::string(StringValuePtr(argv[1]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    return Qnil;
}


static VALUE
_wrap_StrVector_each(int argc, VALUE *argv, VALUE self) {
    std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
    {
        try {
            std_vector_Sl_std_string_Sg__each(arg1);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static void
free_std_vector_Sl_std_string_Sg_(std::vector<std::string > *arg1) {
    delete arg1;
}
static VALUE
_wrap_new_IntVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    std::vector<int > *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = NUM2UINT(argv[0]);
    {
        try {
            result = (std::vector<int > *)new std::vector<int >(arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE
_wrap_new_IntVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        try {
            result = (std::vector<int > *)new std::vector<int >();
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE
_wrap_new_IntVector__SWIG_2(int argc, VALUE *argv, VALUE self) {
    unsigned int arg1 ;
    int *arg2 = 0 ;
    std::vector<int > *result;
    int temp2 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2UINT(argv[0]);
    temp2 = (int) NUM2INT(argv[1]);
    arg2 = &temp2;
    {
        try {
            result = (std::vector<int > *)new std::vector<int >(arg1,(int const &)*arg2);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_IntVector_allocate(VALUE self) {
#else
    static VALUE
    _wrap_IntVector_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorTint_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_IntVector__SWIG_3(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = 0 ;
    std::vector<int > *result;
    std::vector<int > temp1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            temp1 = std::vector<int >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (FIXNUM_P(o))
                temp1[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    {
        try {
            result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE _wrap_new_IntVector(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_IntVector__SWIG_1(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_IntVector__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            /* native sequence? */
            if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
                unsigned int size = RARRAY(argv[0])->len;
                if (size == 0) {
                    /* an empty sequence can be of any type */
                    _v = 1;
                } else {
                    /* check the first element only */
                    VALUE o = RARRAY(argv[0])->ptr[0];
                    if (FIXNUM_P(o))
                    _v = 1;
                    else
                    _v = 0;
                }
            } else {
                /* wrapped vector? */
                std::vector<int >* v;
                if (SWIG_ConvertPtr(argv[0],(void **) &v, 
                SWIGTYPE_p_std__vectorTint_t,0) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_IntVector__SWIG_3(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_IntVector__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_IntVector'");
    return Qnil;
}


static VALUE
_wrap_IntVector___len__(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    unsigned int result;
    std::vector<int > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<int >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                if (FIXNUM_P(o))
                temp1[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    {
        try {
            result = (unsigned int)((std::vector<int > const *)arg1)->size();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_IntVector_emptyq___(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    bool result;
    std::vector<int > temp1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cArray)) {
            unsigned int size = RARRAY(self)->len;
            temp1 = std::vector<int >(size);
            arg1 = &temp1;
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(self)->ptr[i];
                if (FIXNUM_P(o))
                temp1[i] = (int)(FIX2INT(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""int" ">)");
            }
        } else {
            SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
        }
    }
    {
        try {
            result = (bool)((std::vector<int > const *)arg1)->empty();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_IntVector_clear(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    {
        try {
            (arg1)->clear();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_IntVector_push(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            (arg1)->push_back(arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_IntVector_pop(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    {
        try {
            result = (int)std_vector_Sl_int_Sg__pop(arg1);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_IntVector___getitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            result = (int)std_vector_Sl_int_Sg____getitem__(arg1,arg2);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_IntVector___setitem__(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    {
        try {
            std_vector_Sl_int_Sg____setitem__(arg1,arg2,arg3);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    return Qnil;
}


static VALUE
_wrap_IntVector_each(int argc, VALUE *argv, VALUE self) {
    std::vector<int > *arg1 = (std::vector<int > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
    {
        try {
            std_vector_Sl_int_Sg__each(arg1);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static void
free_std_vector_Sl_int_Sg_(std::vector<int > *arg1) {
    delete arg1;
}
static VALUE
_wrap_new_StrStrMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        try {
            result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_StrStrMap_allocate(VALUE self) {
#else
    static VALUE
    _wrap_StrStrMap_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__mapTstd__string_std__string_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_StrStrMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = 0 ;
    std::map<std::string,std::string > *result;
    std::map<std::string,std::string > temp1 ;
    std::map<std::string,std::string > *m1 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cHash)) {
            temp1 = std::map<std::string,std::string >();
            arg1 = &temp1;
            VALUE keys = rb_funcall(argv[0],rb_intern("keys"),0);
            unsigned int size = RARRAY(keys)->len;
            for (unsigned int i=0; i<size; i++) {
                VALUE key = RARRAY(keys)->ptr[i];
                VALUE val = rb_hash_aref(argv[0],key);
                if (!(SWIG_STRING_P(key) && SWIG_STRING_P(val)))
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected map<""std::string" ",""std::string" ">)");
                temp1[SWIG_RB2STR(key)] = SWIG_RB2STR(val);
            }
        } else {
            SWIG_ConvertPtr(argv[0],(void **) &m1, SWIGTYPE_p_std__mapTstd__string_std__string_t,1);
            arg1 = m1;
        }
    }
    {
        try {
            result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE _wrap_new_StrStrMap(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_StrStrMap__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            // native sequence?
            if (rb_obj_is_kind_of(argv[0],rb_cHash)) {
                VALUE keys = rb_funcall(argv[0],rb_intern("keys"),0);
                unsigned int size = RARRAY(keys)->len;
                if (size == 0) {
                    // an empty dictionary can be of any type
                    _v = 1;
                } else {
                    // check the first element only
                    VALUE key = RARRAY(keys)->ptr[0];
                    VALUE val = rb_hash_aref(argv[0],key);
                    if (SWIG_STRING_P(key) && SWIG_STRING_P(val))
                    _v = 1;
                    else
                    _v = 0;
                }
            } else {
                // wrapped map?
                std::map<std::string,std::string >* m;
                if (SWIG_ConvertPtr(argv[0],(void **) &m,
                SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
                _v = 1;
                else
                _v = 0;
            }
        }
        if (_v) {
            return _wrap_new_StrStrMap__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrStrMap'");
    return Qnil;
}


static VALUE
_wrap_StrStrMap___len__(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    unsigned int result;
    std::map<std::string,std::string > temp1 ;
    std::map<std::string,std::string > *m1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cHash)) {
            temp1 = std::map<std::string,std::string >();
            arg1 = &temp1;
            VALUE keys = rb_funcall(self,rb_intern("keys"),0);
            unsigned int size = RARRAY(keys)->len;
            for (unsigned int i=0; i<size; i++) {
                VALUE key = RARRAY(keys)->ptr[i];
                VALUE val = rb_hash_aref(self,key);
                if (!(SWIG_STRING_P(key) && SWIG_STRING_P(val)))
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected map<""std::string" ",""std::string" ">)");
                temp1[SWIG_RB2STR(key)] = SWIG_RB2STR(val);
            }
        } else {
            SWIG_ConvertPtr(self,(void **) &m1, SWIGTYPE_p_std__mapTstd__string_std__string_t,1);
            arg1 = m1;
        }
    }
    {
        try {
            result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_StrStrMap_emptyq___(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    bool result;
    std::map<std::string,std::string > temp1 ;
    std::map<std::string,std::string > *m1 ;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        if (rb_obj_is_kind_of(self,rb_cHash)) {
            temp1 = std::map<std::string,std::string >();
            arg1 = &temp1;
            VALUE keys = rb_funcall(self,rb_intern("keys"),0);
            unsigned int size = RARRAY(keys)->len;
            for (unsigned int i=0; i<size; i++) {
                VALUE key = RARRAY(keys)->ptr[i];
                VALUE val = rb_hash_aref(self,key);
                if (!(SWIG_STRING_P(key) && SWIG_STRING_P(val)))
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected map<""std::string" ",""std::string" ">)");
                temp1[SWIG_RB2STR(key)] = SWIG_RB2STR(val);
            }
        } else {
            SWIG_ConvertPtr(self,(void **) &m1, SWIGTYPE_p_std__mapTstd__string_std__string_t,1);
            arg1 = m1;
        }
    }
    {
        try {
            result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_StrStrMap_clear(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        try {
            (arg1)->clear();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_StrStrMap___getitem__(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            arg2 = std::string(StringValuePtr(argv[0]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            result = std_map_Sl_std_string_Sc_std_string_Sg____getitem__(arg1,arg2);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_StrStrMap___setitem__(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    std::string arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            arg2 = std::string(StringValuePtr(argv[0]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        if (TYPE(argv[1]) == T_STRING) {
            arg3 = std::string(StringValuePtr(argv[1]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            std_map_Sl_std_string_Sc_std_string_Sg____setitem__(arg1,arg2,arg3);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_StrStrMap_delete(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    std::string result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            arg2 = std::string(StringValuePtr(argv[0]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            result = std_map_Sl_std_string_Sc_std_string_Sg____delitem__(arg1,arg2);
            
        } catch (std::out_of_range& e) {
            SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
        }
    }
    {
        vresult = rb_str_new2((&result)->c_str());
    }
    return vresult;
}


static VALUE
_wrap_StrStrMap_has_keyq___(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    std::string arg2 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        if (TYPE(argv[0]) == T_STRING) {
            arg2 = std::string(StringValuePtr(argv[0]));
        } else {
            SWIG_exception(SWIG_TypeError, "not a string");
        }
    }
    {
        try {
            result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key(arg1,arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_StrStrMap_keys(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    VALUE result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        try {
            result = (VALUE)std_map_Sl_std_string_Sc_std_string_Sg__keys(arg1);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result;
    return vresult;
}


static VALUE
_wrap_StrStrMap_values(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    VALUE result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        try {
            result = (VALUE)std_map_Sl_std_string_Sc_std_string_Sg__values(arg1);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result;
    return vresult;
}


static VALUE
_wrap_StrStrMap_each(int argc, VALUE *argv, VALUE self) {
    std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
    {
        try {
            std_map_Sl_std_string_Sc_std_string_Sg__each(arg1);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static void
free_std_map_Sl_std_string_Sc_std_string_Sg_(std::map<std::string,std::string > *arg1) {
    delete arg1;
}
static VALUE
_wrap_Condition_cond_set(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    ESTCOND *arg2 = (ESTCOND *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ESTCOND, 1);
    if (arg1) (arg1)->cond = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Condition_cond_get(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    ESTCOND *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    result = (ESTCOND *) ((arg1)->cond);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ESTCOND,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Condition_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Condition_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_estraier__Condition);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Condition(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        try {
            result = (estraier::Condition *)new estraier::Condition();
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static void
free_estraier_Condition(estraier::Condition *arg1) {
    delete arg1;
}
static VALUE
_wrap_Condition_set_phrase(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    char *arg2 = (char *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    arg2 = StringValuePtr(argv[0]);
    {
        try {
            (arg1)->set_phrase((char const *)arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Condition_add_attr(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    char *arg2 = (char *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    arg2 = StringValuePtr(argv[0]);
    {
        try {
            (arg1)->add_attr((char const *)arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Condition_set_order(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    char *arg2 = (char *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    arg2 = StringValuePtr(argv[0]);
    {
        try {
            (arg1)->set_order((char const *)arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Condition_set_max(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            (arg1)->set_max(arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Condition_set_options(int argc, VALUE *argv, VALUE self) {
    estraier::Condition *arg1 = (estraier::Condition *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
    arg2 = NUM2INT(argv[0]);
    {
        try {
            (arg1)->set_options(arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Document_doc_set(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    ESTDOC *arg2 = (ESTDOC *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ESTDOC, 1);
    if (arg1) (arg1)->doc = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Document_doc_get(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    ESTDOC *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    result = (ESTDOC *) ((arg1)->doc);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ESTDOC,0);
    return vresult;
}


static VALUE
_wrap_new_Document__SWIG_0(int argc, VALUE *argv, VALUE self) {
    estraier::Document *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        try {
            result = (estraier::Document *)new estraier::Document();
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE
_wrap_new_Document__SWIG_1(int argc, VALUE *argv, VALUE self) {
    char *arg1 = (char *) 0 ;
    estraier::Document *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = StringValuePtr(argv[0]);
    {
        try {
            result = (estraier::Document *)new estraier::Document((char const *)arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Document_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Document_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_estraier__Document);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Document__SWIG_2(int argc, VALUE *argv, VALUE self) {
    ESTDOC *arg1 = (ESTDOC *) 0 ;
    estraier::Document *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ESTDOC, 1);
    {
        try {
            result = (estraier::Document *)new estraier::Document(arg1);
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static VALUE _wrap_new_Document(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Document__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_ESTDOC, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Document__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            _v = (TYPE(argv[0]) == T_STRING) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Document__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Document'");
    return Qnil;
}


static void
free_estraier_Document(estraier::Document *arg1) {
    delete arg1;
}
static VALUE
_wrap_Document_add_attr(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    arg2 = StringValuePtr(argv[0]);
    arg3 = StringValuePtr(argv[1]);
    {
        try {
            (arg1)->add_attr((char const *)arg2,(char const *)arg3);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Document_add_text(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    char *arg2 = (char *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    arg2 = StringValuePtr(argv[0]);
    {
        try {
            (arg1)->add_text((char const *)arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Document_add_hidden_text(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    char *arg2 = (char *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    arg2 = StringValuePtr(argv[0]);
    {
        try {
            (arg1)->add_hidden_text((char const *)arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return Qnil;
}


static VALUE
_wrap_Document_id(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    {
        try {
            result = (int)(arg1)->id();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Document_attr_names(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    std::vector<std::string > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    {
        try {
            result = (std::vector<std::string > *)(arg1)->attr_names();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t,0);
    return vresult;
}


static VALUE
_wrap_Document_attr(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    char *arg2 = (char *) 0 ;
    char *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    arg2 = StringValuePtr(argv[0]);
    {
        try {
            result = (char *)(arg1)->attr((char const *)arg2);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = rb_str_new2(result);
    return vresult;
}


static VALUE
_wrap_Document_cat_texts(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    char *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    {
        try {
            result = (char *)(arg1)->cat_texts();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = rb_str_new2(result);
    return vresult;
}


static VALUE
_wrap_Document_texts(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    std::vector<std::string > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    {
        try {
            result = (std::vector<std::string > *)(arg1)->texts();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t,0);
    return vresult;
}


static VALUE
_wrap_Document_dump_draft(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    char *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    {
        try {
            result = (char *)(arg1)->dump_draft();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = rb_str_new2(result);
    return vresult;
}


static VALUE
_wrap_Document_make_snippet(int argc, VALUE *argv, VALUE self) {
    estraier::Document *arg1 = (estraier::Document *) 0 ;
    std::vector<std::string > arg2 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    char *result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
    {
        if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
            unsigned int size = RARRAY(argv[0])->len;
            arg2 = std::vector<std::string >(size);
            for (unsigned int i=0; i<size; i++) {
                VALUE o = RARRAY(argv[0])->ptr[i];
                if (SWIG_STRING_P(o))
                ((std::vector<std::string > &)arg2)[i] = (std::string)(SWIG_RB2STR(o));
                else
                rb_raise(rb_eTypeError,
                "wrong argument type"
                " (expected vector<""std::string" ">)");
            }
        } else {
            void *ptr;
            SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
            arg2 = *((std::vector<std::string > *) ptr);
        }
    }
    arg3 = NUM2INT(argv[1]);
    arg4 = NUM2INT(argv[2]);
    arg5 = NUM2INT(argv[3]);
    {
        try {
            result = (char *)(arg1)->make_snippet(arg2,arg3,arg4,arg5);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = rb_str_new2(result);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Database_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Database_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_estraier__Database);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Database(int argc, VALUE *argv, VALUE self) {
    estraier::Database *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    {
        try {
            result = (estraier::Database *)new estraier::Database();
            DATA_PTR(self) = result;
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    return self;
}


static void
free_estraier_Database(estraier::Database *arg1) {
    delete arg1;
}
static VALUE
_wrap_Database_open(int argc, VALUE *argv, VALUE self) {
    estraier::Database *arg1 = (estraier::Database *) 0 ;
    char *arg2 = (char *) 0 ;
    int arg3 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
    arg2 = StringValuePtr(argv[0]);
    arg3 = NUM2INT(argv[1]);
    {
        try {
            result = (bool)(arg1)->open((char const *)arg2,arg3);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Database_close(int argc, VALUE *argv, VALUE self) {
    estraier::Database *arg1 = (estraier::Database *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
    {
        try {
            result = (bool)(arg1)->close();
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Database_put_doc(int argc, VALUE *argv, VALUE self) {
    estraier::Database *arg1 = (estraier::Database *) 0 ;
    estraier::Document *arg2 = (estraier::Document *) 0 ;
    int arg3 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_estraier__Document, 1);
    arg3 = NUM2INT(argv[1]);
    {
        try {
            result = (bool)(arg1)->put_doc(arg2,arg3);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Database_search(int argc, VALUE *argv, VALUE self) {
    estraier::Database *arg1 = (estraier::Database *) 0 ;
    estraier::Condition *arg2 = (estraier::Condition *) 0 ;
    int arg3 ;
    std::vector<int > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_estraier__Condition, 1);
    arg3 = NUM2INT(argv[1]);
    {
        try {
            result = (std::vector<int > *)(arg1)->search(arg2,arg3);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTint_t,0);
    return vresult;
}


static VALUE
_wrap_Database_err_msg(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    char *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = NUM2INT(argv[0]);
    {
        try {
            result = (char *)estraier::Database::err_msg(arg1);
            
        } catch (const char *msg) {
            SWIG_exception(SWIG_RuntimeError, msg);
        }
    }
    vresult = rb_str_new2(result);
    return vresult;
}


static VALUE
_wrap_Database_error(int argc, VALUE *argv, VALUE self) {
    estraier::Database *arg1 = (estraier::Database *) 0 ;
    int result;
    VALUE vresult = Qnil;