Main Page | Namespace List | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

HyperEstraier_wrap.cxx File Reference

#include "ruby.h"
#include <string.h>
#include <stdexcept>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <utility>
#include "HyperEstraierWrapper.cpp"

Go to the source code of this file.

Classes

struct  swig_class
struct  swig_type_info

Defines

#define SWIG_TEMPLATE_DISAMBIGUATOR
#define SWIGRUBY   1
#define SWIG_POINTER_EXCEPTION   0x1
#define SWIG_POINTER_DISOWN   0x2
#define NUM2USHRT(n)
#define NUM2SHRT(n)
#define NUM2LL(x)   NUM2LONG((x))
#define LL2NUM(x)   INT2NUM((long) (x))
#define ULL2NUM(x)   UINT2NUM((unsigned long) (x))
#define NUM2ULL(x)   NUM2ULONG(x)
#define VALUEFUNC(f)   (f)
#define VOIDFUNC(f)   (f)
#define RB_STRING_VALUE(s)   (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#define StringValue(s)   RB_STRING_VALUE(s)
#define StringValuePtr(s)   RSTRING(RB_STRING_VALUE(s))->ptr
#define StringValueLen(s)   RSTRING(RB_STRING_VALUE(s))->len
#define SafeStringValue(v)
#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")
#define SWIG_contract_assert(expr, msg)   if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else
#define SWIG_RUNTIME_VERSION   "1"
#define SWIG_TYPE_TABLE_NAME
#define SWIGINLINE
#define SWIGRUNTIME   static
#define SWIGRUNTIMEINLINE   SWIGRUNTIME SWIGINLINE
#define SWIGEXPORT(a)   a
#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)
#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)
#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]
#define SWIG_init   Init_HyperEstraier
#define SWIG_name   "HyperEstraier"
#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
#define SWIG_exception(a, b)   SWIG_exception_((a), (b))
#define SWIG_FLOAT_P(x)   ((TYPE(x) == T_FLOAT) || FIXNUM_P(x))

Typedefs

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

Functions

SWIGRUNTIME int SWIG_TypeNameComp (const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME int SWIG_TypeEquiv (const char *nb, const char *tb)
SWIGRUNTIME swig_type_infoSWIG_TypeRegisterTL (swig_type_info **tl, swig_type_info *ti)
SWIGRUNTIME swig_type_infoSWIG_TypeCheck (const char *c, swig_type_info *ty)
SWIGRUNTIMEINLINE void * SWIG_TypeCast (swig_type_info *ty, void *ptr)
SWIGRUNTIME swig_type_infoSWIG_TypeDynamicCast (swig_type_info *ty, void **ptr)
SWIGRUNTIMEINLINE const char * SWIG_TypeName (const swig_type_info *ty)
SWIGRUNTIME const char * SWIG_TypePrettyName (const swig_type_info *type)
SWIGRUNTIME swig_type_infoSWIG_TypeQueryTL (swig_type_info *tl, const char *name)
SWIGRUNTIME void SWIG_TypeClientDataTL (swig_type_info *tl, swig_type_info *ti, void *clientdata)
SWIGRUNTIME char * SWIG_PackData (char *c, void *ptr, size_t sz)
SWIGRUNTIME const char * SWIG_UnpackData (const char *c, void *ptr, size_t sz)
SWIGRUNTIME void SWIG_PropagateClientDataTL (swig_type_info *tl, swig_type_info *type)
SWIGRUNTIME char * SWIG_PackVoidPtr (char *buff, void *ptr, const char *name, size_t bsz)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr (const char *c, void **ptr, const char *name)
SWIGRUNTIME char * SWIG_PackDataName (char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGRUNTIME const char * SWIG_UnpackDataName (const char *c, void *ptr, size_t sz, const char *name)
static swig_type_infoSWIG_TypeRegister (swig_type_info *ti)
static swig_type_infoSWIG_TypeQuery (const char *name)
static void SWIG_TypeClientData (swig_type_info *ti, void *clientdata)
static void SWIG_PropagateClientData (swig_type_info *type)
static void SWIG_Ruby_InitRuntime (void)
static void SWIG_Ruby_define_class (swig_type_info *type)
static VALUE SWIG_Ruby_NewPointerObj (void *ptr, swig_type_info *type, int own)
static VALUE SWIG_Ruby_NewClassInstance (VALUE klass, swig_type_info *type)
static SWIGINLINE char * SWIG_Ruby_MangleStr (VALUE obj)
static int SWIG_Ruby_ConvertPtr (VALUE obj, void **ptr, swig_type_info *ty, int flags)
static SWIGINLINE void * SWIG_Ruby_MustGetPtr (VALUE obj, swig_type_info *ty, int argnum, int flags)
static SWIGINLINE int SWIG_Ruby_CheckConvert (VALUE obj, swig_type_info *ty)
static VALUE SWIG_Ruby_NewPackedObj (void *ptr, int sz, swig_type_info *type)
static void SWIG_Ruby_ConvertPacked (VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags)
static void SWIG_AsVal (VALUE obj, int *val)
static void SWIG_exception_ (int code, const char *msg)
bool SWIG_BOOL_P (VALUE)
bool SWIG_RB2BOOL (VALUE x)
VALUE SWIG_BOOL2RB (bool b)
double SWIG_NUM2DBL (VALUE x)
bool SWIG_STRING_P (VALUE x)
std::string SWIG_RB2STR (VALUE x)
VALUE SWIG_STR2RB (const std::string &s)
static std::string std_vector_Sl_std_string_Sg__pop (std::vector< std::string > *self)
static std::string std_vector_Sl_std_string_Sg____getitem__ (std::vector< std::string > *self, int i)
static void std_vector_Sl_std_string_Sg____setitem__ (std::vector< std::string > *self, int i, std::string x)
static void std_vector_Sl_std_string_Sg__each (std::vector< std::string > *self)
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)
static int std_vector_Sl_int_Sg____getitem__ (std::vector< int > *self, int i)
static void std_vector_Sl_int_Sg____setitem__ (std::vector< int > *self, int i, int x)
static void std_vector_Sl_int_Sg__each (std::vector< int > *self)
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)
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)
static std::string std_map_Sl_std_string_Sc_std_string_Sg____delitem__ (std::map< std::string, std::string > *self, std::string key)
static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key (std::map< std::string, std::string > *self, std::string key)
static VALUE std_map_Sl_std_string_Sc_std_string_Sg__keys (std::map< std::string, std::string > *self)
static VALUE std_map_Sl_std_string_Sc_std_string_Sg__values (std::map< std::string, std::string > *self)
static void std_map_Sl_std_string_Sc_std_string_Sg__each (std::map< std::string, std::string > *self)
static void free_std_map_Sl_std_string_Sc_std_string_Sg_ (std::map< std::string, std::string > *)
static void free_estraier_Condition (estraier::Condition *)
static void free_estraier_Document (estraier::Document *)
static void free_estraier_Database (estraier::Database *)
static VALUE _wrap_new_StrVector__SWIG_0 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrVector__SWIG_1 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrVector__SWIG_2 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector_allocate (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrVector__SWIG_3 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrVector (int nargs, VALUE *args, VALUE self)
static VALUE _wrap_StrVector___len__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector_emptyq___ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector_clear (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector_push (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector_pop (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector___getitem__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector___setitem__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrVector_each (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_IntVector__SWIG_0 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_IntVector__SWIG_1 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_IntVector__SWIG_2 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector_allocate (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_IntVector__SWIG_3 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_IntVector (int nargs, VALUE *args, VALUE self)
static VALUE _wrap_IntVector___len__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector_emptyq___ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector_clear (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector_push (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector_pop (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector___getitem__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector___setitem__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_IntVector_each (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrStrMap__SWIG_0 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_allocate (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrStrMap__SWIG_1 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_StrStrMap (int nargs, VALUE *args, VALUE self)
static VALUE _wrap_StrStrMap___len__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_emptyq___ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_clear (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap___getitem__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap___setitem__ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_delete (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_has_keyq___ (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_keys (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_values (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_StrStrMap_each (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_cond_set (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_cond_get (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_allocate (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_Condition (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_set_phrase (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_add_attr (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_set_order (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_set_max (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Condition_set_options (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_doc_set (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_doc_get (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_Document__SWIG_0 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_Document__SWIG_1 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_allocate (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_Document__SWIG_2 (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_Document (int nargs, VALUE *args, VALUE self)
static VALUE _wrap_Document_add_attr (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_add_text (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_add_hidden_text (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_id (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_attr_names (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_attr (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_cat_texts (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_texts (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_dump_draft (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Document_make_snippet (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_allocate (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_new_Database (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_open (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_close (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_put_doc (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_search (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_err_msg (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_error (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_fatal (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_flush (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_sync (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_optimize (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_out_doc (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_get_doc (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_uri_to_id (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_etch_doc (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_name (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_doc_num (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_word_num (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_size (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_set_cache_size (int argc, VALUE *argv, VALUE self)
static VALUE _wrap_Database_set_special_cache (int argc, VALUE *argv, VALUE self)
 SWIGEXPORT (void) Init_HyperEstraier(void)

Variables

static swig_type_infoswig_type_list = 0
static swig_type_info ** swig_type_list_handle = &swig_type_list
static VALUE _mSWIG = Qnil
static VALUE _cSWIG_Pointer = Qnil
static VALUE swig_runtime_data_type_pointer = Qnil
static swig_type_infoswig_types [10]
static VALUE mHyperEstraier
swig_class cStrVector
swig_class cIntVector
swig_class cStrStrMap
swig_class cCondition
swig_class cDocument
swig_class cDatabase
static swig_type_info _swigt__p_estraier__Condition [] = {{"_p_estraier__Condition", 0, "estraier::Condition *", 0, 0, 0, 0},{"_p_estraier__Condition", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_ESTCOND [] = {{"_p_ESTCOND", 0, "ESTCOND *", 0, 0, 0, 0},{"_p_ESTCOND", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_estraier__Database [] = {{"_p_estraier__Database", 0, "estraier::Database *", 0, 0, 0, 0},{"_p_estraier__Database", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_unsigned_long [] = {{"_p_unsigned_long", 0, "unsigned long *|VALUE *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_ESTDOC [] = {{"_p_ESTDOC", 0, "ESTDOC *", 0, 0, 0, 0},{"_p_ESTDOC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_std__vectorTstd__string_t [] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0, 0, 0, 0},{"_p_std__vectorTstd__string_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_std__mapTstd__string_std__string_t [] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0, 0, 0, 0},{"_p_std__mapTstd__string_std__string_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_std__vectorTint_t [] = {{"_p_std__vectorTint_t", 0, "std::vector<int > *", 0, 0, 0, 0},{"_p_std__vectorTint_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_estraier__Document [] = {{"_p_estraier__Document", 0, "estraier::Document *", 0, 0, 0, 0},{"_p_estraier__Document", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_infoswig_types_initial []


Define Documentation

#define LL2NUM  )     INT2NUM((long) (x))
 

Definition at line 66 of file HyperEstraier_wrap.cxx.

#define NUM2LL  )     NUM2LONG((x))
 

Definition at line 63 of file HyperEstraier_wrap.cxx.

#define NUM2SHRT  ) 
 

Value:

(\
    (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)\
)

Definition at line 54 of file HyperEstraier_wrap.cxx.

#define NUM2ULL  )     NUM2ULONG(x)
 

Definition at line 77 of file HyperEstraier_wrap.cxx.

#define NUM2USHRT  ) 
 

Value:

(\
    (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)\
)

Definition at line 47 of file HyperEstraier_wrap.cxx.

#define rb_define_alloc_func klass,
func   )     rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
 

Definition at line 144 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

#define RB_STRING_VALUE  )     (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
 

Definition at line 125 of file HyperEstraier_wrap.cxx.

#define rb_undef_alloc_func klass   )     rb_undef_method(CLASS_OF((klass)), "new")
 

Definition at line 145 of file HyperEstraier_wrap.cxx.

#define SafeStringValue  ) 
 

Value:

do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)

Definition at line 137 of file HyperEstraier_wrap.cxx.

#define StringValue  )     RB_STRING_VALUE(s)
 

Definition at line 128 of file HyperEstraier_wrap.cxx.

#define StringValueLen  )     RSTRING(RB_STRING_VALUE(s))->len
 

Definition at line 134 of file HyperEstraier_wrap.cxx.

#define StringValuePtr  )     RSTRING(RB_STRING_VALUE(s))->ptr
 

Definition at line 131 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_Condition_add_attr(), _wrap_Condition_set_order(), _wrap_Condition_set_phrase(), _wrap_Database_open(), _wrap_Database_set_special_cache(), _wrap_Database_uri_to_id(), _wrap_Document_add_attr(), _wrap_Document_add_hidden_text(), _wrap_Document_add_text(), _wrap_Document_attr(), _wrap_new_Document__SWIG_1(), _wrap_new_StrVector__SWIG_2(), _wrap_StrStrMap___getitem__(), _wrap_StrStrMap___setitem__(), _wrap_StrStrMap_delete(), _wrap_StrStrMap_has_keyq___(), _wrap_StrVector___setitem__(), _wrap_StrVector_push(), SWIG_RB2STR(), SWIG_Ruby_ConvertPacked(), and SWIG_Ruby_MangleStr().

#define SWIG_CheckConvert value,
ty   )     SWIG_Ruby_CheckConvert(value, ty)
 

Definition at line 637 of file HyperEstraier_wrap.cxx.

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

Definition at line 150 of file HyperEstraier_wrap.cxx.

#define SWIG_ConvertPacked obj,
ptr,
sz,
ty,
flags   )     SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
 

Definition at line 641 of file HyperEstraier_wrap.cxx.

#define SWIG_ConvertPtr obj,
pp,
type,
flags   )     SWIG_Ruby_ConvertPtr(obj, pp, type, flags)
 

Definition at line 620 of file HyperEstraier_wrap.cxx.

#define SWIG_define_class ty   )     SWIG_Ruby_define_class(ty)
 

Definition at line 631 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

#define SWIG_DivisionByZero   6
 

Definition at line 874 of file HyperEstraier_wrap.cxx.

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

Definition at line 922 of file HyperEstraier_wrap.cxx.

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

Definition at line 930 of file HyperEstraier_wrap.cxx.

#define SWIG_IndexError   4
 

Definition at line 872 of file HyperEstraier_wrap.cxx.

#define SWIG_init   Init_HyperEstraier
 

Definition at line 858 of file HyperEstraier_wrap.cxx.

 
#define SWIG_InitRuntime  )     SWIG_Ruby_InitRuntime()
 

Definition at line 629 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

#define SWIG_IOError   2
 

Definition at line 870 of file HyperEstraier_wrap.cxx.

#define SWIG_MangleStr value   )     SWIG_Ruby_MangleStr(value)
 

Definition at line 635 of file HyperEstraier_wrap.cxx.

Referenced by SWIG_Ruby_CheckConvert(), and SWIG_Ruby_ConvertPtr().

#define SWIG_MemoryError   1
 

Definition at line 869 of file HyperEstraier_wrap.cxx.

#define SWIG_MustGetPtr p,
type,
argnum,
flags   )     SWIG_Ruby_MustGetPtr(p, type, argnum, flags)
 

Definition at line 624 of file HyperEstraier_wrap.cxx.

#define SWIG_name   "HyperEstraier"
 

Definition at line 859 of file HyperEstraier_wrap.cxx.

#define SWIG_NewClassInstance value,
ty   )     SWIG_Ruby_NewClassInstance(value, ty)
 

Definition at line 633 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_Condition_allocate(), _wrap_Database_allocate(), _wrap_Document_allocate(), _wrap_IntVector_allocate(), _wrap_StrStrMap_allocate(), and _wrap_StrVector_allocate().

#define SWIG_NewPackedObj ptr,
sz,
ty   )     SWIG_Ruby_NewPackedObj(ptr, sz, ty)
 

Definition at line 639 of file HyperEstraier_wrap.cxx.

#define SWIG_NewPointerObj p,
type,
flags   )     SWIG_Ruby_NewPointerObj(p, type, flags)
 

Definition at line 622 of file HyperEstraier_wrap.cxx.

#define SWIG_OverflowError   7
 

Definition at line 875 of file HyperEstraier_wrap.cxx.

#define SWIG_POINTER_DISOWN   0x2
 

Definition at line 45 of file HyperEstraier_wrap.cxx.

#define SWIG_POINTER_EXCEPTION   0x1
 

Definition at line 44 of file HyperEstraier_wrap.cxx.

Referenced by SWIG_Ruby_ConvertPtr(), and SWIG_Ruby_MustGetPtr().

#define SWIG_RUNTIME_VERSION   "1"
 

Definition at line 163 of file HyperEstraier_wrap.cxx.

#define SWIG_RuntimeError   3
 

Definition at line 871 of file HyperEstraier_wrap.cxx.

#define SWIG_SyntaxError   8
 

Definition at line 876 of file HyperEstraier_wrap.cxx.

#define SWIG_SystemError   10
 

Definition at line 878 of file HyperEstraier_wrap.cxx.

#define SWIG_TEMPLATE_DISAMBIGUATOR
 

Definition at line 33 of file HyperEstraier_wrap.cxx.

#define SWIG_TYPE_TABLE_NAME
 

Definition at line 171 of file HyperEstraier_wrap.cxx.

#define SWIG_TypeError   5
 

Definition at line 873 of file HyperEstraier_wrap.cxx.

#define SWIG_UnknownError   99
 

Definition at line 879 of file HyperEstraier_wrap.cxx.

#define SWIG_ValueError   9
 

Definition at line 877 of file HyperEstraier_wrap.cxx.

#define SWIGEXPORT  )     a
 

Definition at line 570 of file HyperEstraier_wrap.cxx.

#define SWIGINLINE
 

Definition at line 180 of file HyperEstraier_wrap.cxx.

#define SWIGRUBY   1
 

Definition at line 39 of file HyperEstraier_wrap.cxx.

#define SWIGRUNTIME   static
 

Definition at line 193 of file HyperEstraier_wrap.cxx.

#define SWIGRUNTIMEINLINE   SWIGRUNTIME SWIGINLINE
 

Definition at line 196 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_ESTCOND   swig_types[1]
 

Definition at line 846 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_ESTDOC   swig_types[4]
 

Definition at line 849 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_estraier__Condition   swig_types[0]
 

Definition at line 845 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_estraier__Database   swig_types[2]
 

Definition at line 847 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_estraier__Document   swig_types[8]
 

Definition at line 853 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_std__mapTstd__string_std__string_t   swig_types[6]
 

Definition at line 851 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_std__vectorTint_t   swig_types[7]
 

Definition at line 852 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_std__vectorTstd__string_t   swig_types[5]
 

Definition at line 850 of file HyperEstraier_wrap.cxx.

#define SWIGTYPE_p_unsigned_long   swig_types[3]
 

Definition at line 848 of file HyperEstraier_wrap.cxx.

#define ULL2NUM  )     UINT2NUM((unsigned long) (x))
 

Definition at line 69 of file HyperEstraier_wrap.cxx.

#define VALUEFUNC  )     (f)
 

Definition at line 112 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

#define VOIDFUNC  )     (f)
 

Definition at line 113 of file HyperEstraier_wrap.cxx.

Referenced by SWIG_Ruby_NewClassInstance(), and SWIG_Ruby_NewPointerObj().


Typedef Documentation

typedef void*(* swig_converter_func)(void *)
 

Definition at line 203 of file HyperEstraier_wrap.cxx.

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

Definition at line 204 of file HyperEstraier_wrap.cxx.

typedef struct swig_type_info swig_type_info
 


Function Documentation

static VALUE _wrap_Condition_add_attr int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2442 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02442                                                             {
02443     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02444     char *arg2 = (char *) 0 ;
02445     
02446     if ((argc < 1) || (argc > 1))
02447     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02448     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02449     arg2 = StringValuePtr(argv[0]);
02450     {
02451         try {
02452             (arg1)->add_attr((char const *)arg2);
02453             
02454         } catch (const char *msg) {
02455             SWIG_exception(SWIG_RuntimeError, msg);
02456         }
02457     }
02458     return Qnil;
02459 }

static VALUE _wrap_Condition_allocate int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2386 of file HyperEstraier_wrap.cxx.

References SWIG_NewClassInstance, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02386                                                                 {
02387 #endif
02388         
02389         
02390         VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_estraier__Condition);
02391 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
02392         rb_obj_call_init(vresult, argc, argv);
02393 #endif
02394         return vresult;
02395     }

static VALUE _wrap_Condition_cond_get int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2366 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_NewPointerObj, SWIGTYPE_p_ESTCOND, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02366                                                             {
02367     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02368     ESTCOND *result;
02369     VALUE vresult = Qnil;
02370     
02371     if ((argc < 0) || (argc > 0))
02372     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02373     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02374     result = (ESTCOND *) ((arg1)->cond);
02375     
02376     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ESTCOND,0);
02377     return vresult;
02378 }

static VALUE _wrap_Condition_cond_set int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2351 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIGTYPE_p_ESTCOND, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02351                                                             {
02352     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02353     ESTCOND *arg2 = (ESTCOND *) 0 ;
02354     
02355     if ((argc < 1) || (argc > 1))
02356     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02357     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02358     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ESTCOND, 1);
02359     if (arg1) (arg1)->cond = arg2;
02360     
02361     return Qnil;
02362 }

static VALUE _wrap_Condition_set_max int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2484 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02484                                                            {
02485     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02486     int arg2 ;
02487     
02488     if ((argc < 1) || (argc > 1))
02489     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02490     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02491     arg2 = NUM2INT(argv[0]);
02492     {
02493         try {
02494             (arg1)->set_max(arg2);
02495             
02496         } catch (const char *msg) {
02497             SWIG_exception(SWIG_RuntimeError, msg);
02498         }
02499     }
02500     return Qnil;
02501 }

static VALUE _wrap_Condition_set_options int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2505 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02505                                                                {
02506     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02507     int arg2 ;
02508     
02509     if ((argc < 1) || (argc > 1))
02510     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02511     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02512     arg2 = NUM2INT(argv[0]);
02513     {
02514         try {
02515             (arg1)->set_options(arg2);
02516             
02517         } catch (const char *msg) {
02518             SWIG_exception(SWIG_RuntimeError, msg);
02519         }
02520     }
02521     return Qnil;
02522 }

static VALUE _wrap_Condition_set_order int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2463 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02463                                                              {
02464     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02465     char *arg2 = (char *) 0 ;
02466     
02467     if ((argc < 1) || (argc > 1))
02468     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02469     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02470     arg2 = StringValuePtr(argv[0]);
02471     {
02472         try {
02473             (arg1)->set_order((char const *)arg2);
02474             
02475         } catch (const char *msg) {
02476             SWIG_exception(SWIG_RuntimeError, msg);
02477         }
02478     }
02479     return Qnil;
02480 }

static VALUE _wrap_Condition_set_phrase int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2421 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

Referenced by SWIGEXPORT().

02421                                                               {
02422     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02423     char *arg2 = (char *) 0 ;
02424     
02425     if ((argc < 1) || (argc > 1))
02426     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02427     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Condition, 1);
02428     arg2 = StringValuePtr(argv[0]);
02429     {
02430         try {
02431             (arg1)->set_phrase((char const *)arg2);
02432             
02433         } catch (const char *msg) {
02434             SWIG_exception(SWIG_RuntimeError, msg);
02435         }
02436     }
02437     return Qnil;
02438 }

static VALUE _wrap_Database_allocate int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2924 of file HyperEstraier_wrap.cxx.

References SWIG_NewClassInstance, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

02924                                                                {
02925 #endif
02926         
02927         
02928         VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_estraier__Database);
02929 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
02930         rb_obj_call_init(vresult, argc, argv);
02931 #endif
02932         return vresult;
02933     }

static VALUE _wrap_Database_close int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2985 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

02985                                                         {
02986     estraier::Database *arg1 = (estraier::Database *) 0 ;
02987     bool result;
02988     VALUE vresult = Qnil;
02989     
02990     if ((argc < 0) || (argc > 0))
02991     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02992     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
02993     {
02994         try {
02995             result = (bool)(arg1)->close();
02996             
02997         } catch (const char *msg) {
02998             SWIG_exception(SWIG_RuntimeError, msg);
02999         }
03000     }
03001     vresult = result ? Qtrue : Qfalse;
03002     return vresult;
03003 }

static VALUE _wrap_Database_doc_num int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3319 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03319                                                           {
03320     estraier::Database *arg1 = (estraier::Database *) 0 ;
03321     int result;
03322     VALUE vresult = Qnil;
03323     
03324     if ((argc < 0) || (argc > 0))
03325     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03326     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03327     {
03328         try {
03329             result = (int)(arg1)->doc_num();
03330             
03331         } catch (const char *msg) {
03332             SWIG_exception(SWIG_RuntimeError, msg);
03333         }
03334     }
03335     vresult = INT2NUM(result);
03336     return vresult;
03337 }

static VALUE _wrap_Database_err_msg int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3059 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by SWIGEXPORT().

03059                                                           {
03060     int arg1 ;
03061     char *result;
03062     VALUE vresult = Qnil;
03063     
03064     if ((argc < 1) || (argc > 1))
03065     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
03066     arg1 = NUM2INT(argv[0]);
03067     {
03068         try {
03069             result = (char *)estraier::Database::err_msg(arg1);
03070             
03071         } catch (const char *msg) {
03072             SWIG_exception(SWIG_RuntimeError, msg);
03073         }
03074     }
03075     vresult = rb_str_new2(result);
03076     return vresult;
03077 }

static VALUE _wrap_Database_error int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3081 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03081                                                         {
03082     estraier::Database *arg1 = (estraier::Database *) 0 ;
03083     int result;
03084     VALUE vresult = Qnil;
03085     
03086     if ((argc < 0) || (argc > 0))
03087     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03088     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03089     {
03090         try {
03091             result = (int)(arg1)->error();
03092             
03093         } catch (const char *msg) {
03094             SWIG_exception(SWIG_RuntimeError, msg);
03095         }
03096     }
03097     vresult = INT2NUM(result);
03098     return vresult;
03099 }

static VALUE _wrap_Database_etch_doc int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3271 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_NewPointerObj, SWIG_RuntimeError, SWIGTYPE_p_estraier__Database, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

03271                                                            {
03272     estraier::Database *arg1 = (estraier::Database *) 0 ;
03273     estraier::Document *arg2 = (estraier::Document *) 0 ;
03274     int arg3 ;
03275     std::map<std::string,std::string > *result;
03276     VALUE vresult = Qnil;
03277     
03278     if ((argc < 2) || (argc > 2))
03279     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
03280     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03281     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_estraier__Document, 1);
03282     arg3 = NUM2INT(argv[1]);
03283     {
03284         try {
03285             result = (std::map<std::string,std::string > *)(arg1)->etch_doc(arg2,arg3);
03286             
03287         } catch (const char *msg) {
03288             SWIG_exception(SWIG_RuntimeError, msg);
03289         }
03290     }
03291     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t,0);
03292     return vresult;
03293 }

static VALUE _wrap_Database_fatal int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3103 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03103                                                         {
03104     estraier::Database *arg1 = (estraier::Database *) 0 ;
03105     bool result;
03106     VALUE vresult = Qnil;
03107     
03108     if ((argc < 0) || (argc > 0))
03109     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03110     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03111     {
03112         try {
03113             result = (bool)(arg1)->fatal();
03114             
03115         } catch (const char *msg) {
03116             SWIG_exception(SWIG_RuntimeError, msg);
03117         }
03118     }
03119     vresult = result ? Qtrue : Qfalse;
03120     return vresult;
03121 }

static VALUE _wrap_Database_flush int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3125 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03125                                                         {
03126     estraier::Database *arg1 = (estraier::Database *) 0 ;
03127     int arg2 ;
03128     bool result;
03129     VALUE vresult = Qnil;
03130     
03131     if ((argc < 1) || (argc > 1))
03132     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
03133     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03134     arg2 = NUM2INT(argv[0]);
03135     {
03136         try {
03137             result = (bool)(arg1)->flush(arg2);
03138             
03139         } catch (const char *msg) {
03140             SWIG_exception(SWIG_RuntimeError, msg);
03141         }
03142     }
03143     vresult = result ? Qtrue : Qfalse;
03144     return vresult;
03145 }

static VALUE _wrap_Database_get_doc int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3221 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_NewPointerObj, SWIG_RuntimeError, SWIGTYPE_p_estraier__Database, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

03221                                                           {
03222     estraier::Database *arg1 = (estraier::Database *) 0 ;
03223     int arg2 ;
03224     int arg3 ;
03225     estraier::Document *result;
03226     VALUE vresult = Qnil;
03227     
03228     if ((argc < 2) || (argc > 2))
03229     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
03230     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03231     arg2 = NUM2INT(argv[0]);
03232     arg3 = NUM2INT(argv[1]);
03233     {
03234         try {
03235             result = (estraier::Document *)(arg1)->get_doc(arg2,arg3);
03236             
03237         } catch (const char *msg) {
03238             SWIG_exception(SWIG_RuntimeError, msg);
03239         }
03240     }
03241     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_estraier__Document,0);
03242     return vresult;
03243 }

static VALUE _wrap_Database_name int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3297 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03297                                                        {
03298     estraier::Database *arg1 = (estraier::Database *) 0 ;
03299     char *result;
03300     VALUE vresult = Qnil;
03301     
03302     if ((argc < 0) || (argc > 0))
03303     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03304     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03305     {
03306         try {
03307             result = (char *)(arg1)->name();
03308             
03309         } catch (const char *msg) {
03310             SWIG_exception(SWIG_RuntimeError, msg);
03311         }
03312     }
03313     vresult = rb_str_new2(result);
03314     return vresult;
03315 }

static VALUE _wrap_Database_open int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2959 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

02959                                                        {
02960     estraier::Database *arg1 = (estraier::Database *) 0 ;
02961     char *arg2 = (char *) 0 ;
02962     int arg3 ;
02963     bool result;
02964     VALUE vresult = Qnil;
02965     
02966     if ((argc < 2) || (argc > 2))
02967     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
02968     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
02969     arg2 = StringValuePtr(argv[0]);
02970     arg3 = NUM2INT(argv[1]);
02971     {
02972         try {
02973             result = (bool)(arg1)->open((char const *)arg2,arg3);
02974             
02975         } catch (const char *msg) {
02976             SWIG_exception(SWIG_RuntimeError, msg);
02977         }
02978     }
02979     vresult = result ? Qtrue : Qfalse;
02980     return vresult;
02981 }

static VALUE _wrap_Database_optimize int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3171 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03171                                                            {
03172     estraier::Database *arg1 = (estraier::Database *) 0 ;
03173     int arg2 ;
03174     bool result;
03175     VALUE vresult = Qnil;
03176     
03177     if ((argc < 1) || (argc > 1))
03178     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
03179     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03180     arg2 = NUM2INT(argv[0]);
03181     {
03182         try {
03183             result = (bool)(arg1)->optimize(arg2);
03184             
03185         } catch (const char *msg) {
03186             SWIG_exception(SWIG_RuntimeError, msg);
03187         }
03188     }
03189     vresult = result ? Qtrue : Qfalse;
03190     return vresult;
03191 }

static VALUE _wrap_Database_out_doc int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3195 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03195                                                           {
03196     estraier::Database *arg1 = (estraier::Database *) 0 ;
03197     int arg2 ;
03198     int arg3 ;
03199     bool result;
03200     VALUE vresult = Qnil;
03201     
03202     if ((argc < 2) || (argc > 2))
03203     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
03204     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03205     arg2 = NUM2INT(argv[0]);
03206     arg3 = NUM2INT(argv[1]);
03207     {
03208         try {
03209             result = (bool)(arg1)->out_doc(arg2,arg3);
03210             
03211         } catch (const char *msg) {
03212             SWIG_exception(SWIG_RuntimeError, msg);
03213         }
03214     }
03215     vresult = result ? Qtrue : Qfalse;
03216     return vresult;
03217 }

static VALUE _wrap_Database_put_doc int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3007 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, SWIGTYPE_p_estraier__Database, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

03007                                                           {
03008     estraier::Database *arg1 = (estraier::Database *) 0 ;
03009     estraier::Document *arg2 = (estraier::Document *) 0 ;
03010     int arg3 ;
03011     bool result;
03012     VALUE vresult = Qnil;
03013     
03014     if ((argc < 2) || (argc > 2))
03015     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
03016     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03017     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_estraier__Document, 1);
03018     arg3 = NUM2INT(argv[1]);
03019     {
03020         try {
03021             result = (bool)(arg1)->put_doc(arg2,arg3);
03022             
03023         } catch (const char *msg) {
03024             SWIG_exception(SWIG_RuntimeError, msg);
03025         }
03026     }
03027     vresult = result ? Qtrue : Qfalse;
03028     return vresult;
03029 }

static VALUE _wrap_Database_search int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3033 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_NewPointerObj, SWIG_RuntimeError, SWIGTYPE_p_estraier__Condition, SWIGTYPE_p_estraier__Database, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

03033                                                          {
03034     estraier::Database *arg1 = (estraier::Database *) 0 ;
03035     estraier::Condition *arg2 = (estraier::Condition *) 0 ;
03036     int arg3 ;
03037     std::vector<int > *result;
03038     VALUE vresult = Qnil;
03039     
03040     if ((argc < 2) || (argc > 2))
03041     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
03042     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03043     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_estraier__Condition, 1);
03044     arg3 = NUM2INT(argv[1]);
03045     {
03046         try {
03047             result = (std::vector<int > *)(arg1)->search(arg2,arg3);
03048             
03049         } catch (const char *msg) {
03050             SWIG_exception(SWIG_RuntimeError, msg);
03051         }
03052     }
03053     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTint_t,0);
03054     return vresult;
03055 }

static VALUE _wrap_Database_set_cache_size int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3385 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03385                                                                  {
03386     estraier::Database *arg1 = (estraier::Database *) 0 ;
03387     size_t arg2 ;
03388     int arg3 ;
03389     int arg4 ;
03390     
03391     if ((argc < 3) || (argc > 3))
03392     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
03393     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03394     arg2 = NUM2ULONG(argv[0]);
03395     arg3 = NUM2INT(argv[1]);
03396     arg4 = NUM2INT(argv[2]);
03397     {
03398         try {
03399             (arg1)->set_cache_size(arg2,arg3,arg4);
03400             
03401         } catch (const char *msg) {
03402             SWIG_exception(SWIG_RuntimeError, msg);
03403         }
03404     }
03405     return Qnil;
03406 }

static VALUE _wrap_Database_set_special_cache int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3410 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03410                                                                     {
03411     estraier::Database *arg1 = (estraier::Database *) 0 ;
03412     char *arg2 = (char *) 0 ;
03413     int arg3 ;
03414     
03415     if ((argc < 2) || (argc > 2))
03416     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
03417     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03418     arg2 = StringValuePtr(argv[0]);
03419     arg3 = NUM2INT(argv[1]);
03420     {
03421         try {
03422             (arg1)->set_special_cache((char const *)arg2,arg3);
03423             
03424         } catch (const char *msg) {
03425             SWIG_exception(SWIG_RuntimeError, msg);
03426         }
03427     }
03428     return Qnil;
03429 }

static VALUE _wrap_Database_size int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3363 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03363                                                        {
03364     estraier::Database *arg1 = (estraier::Database *) 0 ;
03365     double result;
03366     VALUE vresult = Qnil;
03367     
03368     if ((argc < 0) || (argc > 0))
03369     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03370     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03371     {
03372         try {
03373             result = (double)(arg1)->size();
03374             
03375         } catch (const char *msg) {
03376             SWIG_exception(SWIG_RuntimeError, msg);
03377         }
03378     }
03379     vresult = rb_float_new(result);
03380     return vresult;
03381 }

static VALUE _wrap_Database_sync int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3149 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03149                                                        {
03150     estraier::Database *arg1 = (estraier::Database *) 0 ;
03151     bool result;
03152     VALUE vresult = Qnil;
03153     
03154     if ((argc < 0) || (argc > 0))
03155     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03156     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03157     {
03158         try {
03159             result = (bool)(arg1)->sync();
03160             
03161         } catch (const char *msg) {
03162             SWIG_exception(SWIG_RuntimeError, msg);
03163         }
03164     }
03165     vresult = result ? Qtrue : Qfalse;
03166     return vresult;
03167 }

static VALUE _wrap_Database_uri_to_id int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3247 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03247                                                             {
03248     estraier::Database *arg1 = (estraier::Database *) 0 ;
03249     char *arg2 = (char *) 0 ;
03250     int result;
03251     VALUE vresult = Qnil;
03252     
03253     if ((argc < 1) || (argc > 1))
03254     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
03255     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03256     arg2 = StringValuePtr(argv[0]);
03257     {
03258         try {
03259             result = (int)(arg1)->uri_to_id((char const *)arg2);
03260             
03261         } catch (const char *msg) {
03262             SWIG_exception(SWIG_RuntimeError, msg);
03263         }
03264     }
03265     vresult = INT2NUM(result);
03266     return vresult;
03267 }

static VALUE _wrap_Database_word_num int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 3341 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

Referenced by SWIGEXPORT().

03341                                                            {
03342     estraier::Database *arg1 = (estraier::Database *) 0 ;
03343     int result;
03344     VALUE vresult = Qnil;
03345     
03346     if ((argc < 0) || (argc > 0))
03347     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
03348     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Database, 1);
03349     {
03350         try {
03351             result = (int)(arg1)->word_num();
03352             
03353         } catch (const char *msg) {
03354             SWIG_exception(SWIG_RuntimeError, msg);
03355         }
03356     }
03357     vresult = INT2NUM(result);
03358     return vresult;
03359 }

static VALUE _wrap_Document_add_attr int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2673 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02673                                                            {
02674     estraier::Document *arg1 = (estraier::Document *) 0 ;
02675     char *arg2 = (char *) 0 ;
02676     char *arg3 = (char *) 0 ;
02677     
02678     if ((argc < 2) || (argc > 2))
02679     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
02680     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02681     arg2 = StringValuePtr(argv[0]);
02682     arg3 = StringValuePtr(argv[1]);
02683     {
02684         try {
02685             (arg1)->add_attr((char const *)arg2,(char const *)arg3);
02686             
02687         } catch (const char *msg) {
02688             SWIG_exception(SWIG_RuntimeError, msg);
02689         }
02690     }
02691     return Qnil;
02692 }

static VALUE _wrap_Document_add_hidden_text int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2717 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02717                                                                   {
02718     estraier::Document *arg1 = (estraier::Document *) 0 ;
02719     char *arg2 = (char *) 0 ;
02720     
02721     if ((argc < 1) || (argc > 1))
02722     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02723     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02724     arg2 = StringValuePtr(argv[0]);
02725     {
02726         try {
02727             (arg1)->add_hidden_text((char const *)arg2);
02728             
02729         } catch (const char *msg) {
02730             SWIG_exception(SWIG_RuntimeError, msg);
02731         }
02732     }
02733     return Qnil;
02734 }

static VALUE _wrap_Document_add_text int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2696 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02696                                                            {
02697     estraier::Document *arg1 = (estraier::Document *) 0 ;
02698     char *arg2 = (char *) 0 ;
02699     
02700     if ((argc < 1) || (argc > 1))
02701     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02702     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02703     arg2 = StringValuePtr(argv[0]);
02704     {
02705         try {
02706             (arg1)->add_text((char const *)arg2);
02707             
02708         } catch (const char *msg) {
02709             SWIG_exception(SWIG_RuntimeError, msg);
02710         }
02711     }
02712     return Qnil;
02713 }

static VALUE _wrap_Document_allocate int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2599 of file HyperEstraier_wrap.cxx.

References SWIG_NewClassInstance, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02599                                                                {
02600 #endif
02601         
02602         
02603         VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_estraier__Document);
02604 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
02605         rb_obj_call_init(vresult, argc, argv);
02606 #endif
02607         return vresult;
02608     }

static VALUE _wrap_Document_attr int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2782 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02782                                                        {
02783     estraier::Document *arg1 = (estraier::Document *) 0 ;
02784     char *arg2 = (char *) 0 ;
02785     char *result;
02786     VALUE vresult = Qnil;
02787     
02788     if ((argc < 1) || (argc > 1))
02789     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02790     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02791     arg2 = StringValuePtr(argv[0]);
02792     {
02793         try {
02794             result = (char *)(arg1)->attr((char const *)arg2);
02795             
02796         } catch (const char *msg) {
02797             SWIG_exception(SWIG_RuntimeError, msg);
02798         }
02799     }
02800     vresult = rb_str_new2(result);
02801     return vresult;
02802 }

static VALUE _wrap_Document_attr_names int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2760 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_NewPointerObj, SWIG_RuntimeError, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

02760                                                              {
02761     estraier::Document *arg1 = (estraier::Document *) 0 ;
02762     std::vector<std::string > *result;
02763     VALUE vresult = Qnil;
02764     
02765     if ((argc < 0) || (argc > 0))
02766     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02767     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02768     {
02769         try {
02770             result = (std::vector<std::string > *)(arg1)->attr_names();
02771             
02772         } catch (const char *msg) {
02773             SWIG_exception(SWIG_RuntimeError, msg);
02774         }
02775     }
02776     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t,0);
02777     return vresult;
02778 }

static VALUE _wrap_Document_cat_texts int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2806 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02806                                                             {
02807     estraier::Document *arg1 = (estraier::Document *) 0 ;
02808     char *result;
02809     VALUE vresult = Qnil;
02810     
02811     if ((argc < 0) || (argc > 0))
02812     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02813     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02814     {
02815         try {
02816             result = (char *)(arg1)->cat_texts();
02817             
02818         } catch (const char *msg) {
02819             SWIG_exception(SWIG_RuntimeError, msg);
02820         }
02821     }
02822     vresult = rb_str_new2(result);
02823     return vresult;
02824 }

static VALUE _wrap_Document_doc_get int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2541 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_NewPointerObj, SWIGTYPE_p_ESTDOC, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02541                                                           {
02542     estraier::Document *arg1 = (estraier::Document *) 0 ;
02543     ESTDOC *result;
02544     VALUE vresult = Qnil;
02545     
02546     if ((argc < 0) || (argc > 0))
02547     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02548     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02549     result = (ESTDOC *) ((arg1)->doc);
02550     
02551     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ESTDOC,0);
02552     return vresult;
02553 }

static VALUE _wrap_Document_doc_set int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2526 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIGTYPE_p_ESTDOC, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02526                                                           {
02527     estraier::Document *arg1 = (estraier::Document *) 0 ;
02528     ESTDOC *arg2 = (ESTDOC *) 0 ;
02529     
02530     if ((argc < 1) || (argc > 1))
02531     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02532     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02533     SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ESTDOC, 1);
02534     if (arg1) (arg1)->doc = arg2;
02535     
02536     return Qnil;
02537 }

static VALUE _wrap_Document_dump_draft int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2850 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02850                                                              {
02851     estraier::Document *arg1 = (estraier::Document *) 0 ;
02852     char *result;
02853     VALUE vresult = Qnil;
02854     
02855     if ((argc < 0) || (argc > 0))
02856     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02857     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02858     {
02859         try {
02860             result = (char *)(arg1)->dump_draft();
02861             
02862         } catch (const char *msg) {
02863             SWIG_exception(SWIG_RuntimeError, msg);
02864         }
02865     }
02866     vresult = rb_str_new2(result);
02867     return vresult;
02868 }

static VALUE _wrap_Document_id int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2738 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

Referenced by SWIGEXPORT().

02738                                                      {
02739     estraier::Document *arg1 = (estraier::Document *) 0 ;
02740     int result;
02741     VALUE vresult = Qnil;
02742     
02743     if ((argc < 0) || (argc > 0))
02744     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02745     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02746     {
02747         try {
02748             result = (int)(arg1)->id();
02749             
02750         } catch (const char *msg) {
02751             SWIG_exception(SWIG_RuntimeError, msg);
02752         }
02753     }
02754     vresult = INT2NUM(result);
02755     return vresult;
02756 }

static VALUE _wrap_Document_make_snippet int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2872 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

02872                                                                {
02873     estraier::Document *arg1 = (estraier::Document *) 0 ;
02874     std::vector<std::string > arg2 ;
02875     int arg3 ;
02876     int arg4 ;
02877     int arg5 ;
02878     char *result;
02879     VALUE vresult = Qnil;
02880     
02881     if ((argc < 4) || (argc > 4))
02882     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
02883     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02884     {
02885         if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
02886             unsigned int size = RARRAY(argv[0])->len;
02887             arg2 = std::vector<std::string >(size);
02888             for (unsigned int i=0; i<size; i++) {
02889                 VALUE o = RARRAY(argv[0])->ptr[i];
02890                 if (SWIG_STRING_P(o))
02891                 ((std::vector<std::string > &)arg2)[i] = (std::string)(SWIG_RB2STR(o));
02892                 else
02893                 rb_raise(rb_eTypeError,
02894                 "wrong argument type"
02895                 " (expected vector<""std::string" ">)");
02896             }
02897         } else {
02898             void *ptr;
02899             SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
02900             arg2 = *((std::vector<std::string > *) ptr);
02901         }
02902     }
02903     arg3 = NUM2INT(argv[1]);
02904     arg4 = NUM2INT(argv[2]);
02905     arg5 = NUM2INT(argv[3]);
02906     {
02907         try {
02908             result = (char *)(arg1)->make_snippet(arg2,arg3,arg4,arg5);
02909             
02910         } catch (const char *msg) {
02911             SWIG_exception(SWIG_RuntimeError, msg);
02912         }
02913     }
02914     vresult = rb_str_new2(result);
02915     return vresult;
02916 }

static VALUE _wrap_Document_texts int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2828 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_NewPointerObj, SWIG_RuntimeError, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

02828                                                         {
02829     estraier::Document *arg1 = (estraier::Document *) 0 ;
02830     std::vector<std::string > *result;
02831     VALUE vresult = Qnil;
02832     
02833     if ((argc < 0) || (argc > 0))
02834     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02835     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_estraier__Document, 1);
02836     {
02837         try {
02838             result = (std::vector<std::string > *)(arg1)->texts();
02839             
02840         } catch (const char *msg) {
02841             SWIG_exception(SWIG_RuntimeError, msg);
02842         }
02843     }
02844     vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t,0);
02845     return vresult;
02846 }

static VALUE _wrap_IntVector___getitem__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1853 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_int_Sg____getitem__(), SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01853                                                                {
01854     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01855     int arg2 ;
01856     int result;
01857     VALUE vresult = Qnil;
01858     
01859     if ((argc < 1) || (argc > 1))
01860     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01861     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01862     arg2 = NUM2INT(argv[0]);
01863     {
01864         try {
01865             result = (int)std_vector_Sl_int_Sg____getitem__(arg1,arg2);
01866             
01867         } catch (std::out_of_range& e) {
01868             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01869         }
01870     }
01871     vresult = INT2NUM(result);
01872     return vresult;
01873 }

static VALUE _wrap_IntVector___len__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1711 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01711                                                            {
01712     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01713     unsigned int result;
01714     std::vector<int > temp1 ;
01715     VALUE vresult = Qnil;
01716     
01717     if ((argc < 0) || (argc > 0))
01718     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01719     {
01720         if (rb_obj_is_kind_of(self,rb_cArray)) {
01721             unsigned int size = RARRAY(self)->len;
01722             temp1 = std::vector<int >(size);
01723             arg1 = &temp1;
01724             for (unsigned int i=0; i<size; i++) {
01725                 VALUE o = RARRAY(self)->ptr[i];
01726                 if (FIXNUM_P(o))
01727                 temp1[i] = (int)(FIX2INT(o));
01728                 else
01729                 rb_raise(rb_eTypeError,
01730                 "wrong argument type"
01731                 " (expected vector<""int" ">)");
01732             }
01733         } else {
01734             SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01735         }
01736     }
01737     {
01738         try {
01739             result = (unsigned int)((std::vector<int > const *)arg1)->size();
01740             
01741         } catch (const char *msg) {
01742             SWIG_exception(SWIG_RuntimeError, msg);
01743         }
01744     }
01745     vresult = UINT2NUM(result);
01746     return vresult;
01747 }

static VALUE _wrap_IntVector___setitem__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1877 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_int_Sg____setitem__(), SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01877                                                                {
01878     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01879     int arg2 ;
01880     int arg3 ;
01881     
01882     if ((argc < 2) || (argc > 2))
01883     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
01884     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01885     arg2 = NUM2INT(argv[0]);
01886     arg3 = NUM2INT(argv[1]);
01887     {
01888         try {
01889             std_vector_Sl_int_Sg____setitem__(arg1,arg2,arg3);
01890             
01891         } catch (std::out_of_range& e) {
01892             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01893         }
01894     }
01895     return Qnil;
01896 }

static VALUE _wrap_IntVector_allocate int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1588 of file HyperEstraier_wrap.cxx.

References SWIG_NewClassInstance, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01588                                                                 {
01589 #endif
01590         
01591         
01592         VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorTint_t);
01593 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
01594         rb_obj_call_init(vresult, argc, argv);
01595 #endif
01596         return vresult;
01597     }

static VALUE _wrap_IntVector_clear int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1791 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01791                                                          {
01792     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01793     
01794     if ((argc < 0) || (argc > 0))
01795     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01796     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01797     {
01798         try {
01799             (arg1)->clear();
01800             
01801         } catch (const char *msg) {
01802             SWIG_exception(SWIG_RuntimeError, msg);
01803         }
01804     }
01805     return Qnil;
01806 }

static VALUE _wrap_IntVector_each int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1900 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_int_Sg__each(), SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01900                                                         {
01901     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01902     
01903     if ((argc < 0) || (argc > 0))
01904     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01905     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01906     {
01907         try {
01908             std_vector_Sl_int_Sg__each(arg1);
01909             
01910         } catch (const char *msg) {
01911             SWIG_exception(SWIG_RuntimeError, msg);
01912         }
01913     }
01914     return Qnil;
01915 }

static VALUE _wrap_IntVector_emptyq___ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1751 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01751                                                              {
01752     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01753     bool result;
01754     std::vector<int > temp1 ;
01755     VALUE vresult = Qnil;
01756     
01757     if ((argc < 0) || (argc > 0))
01758     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01759     {
01760         if (rb_obj_is_kind_of(self,rb_cArray)) {
01761             unsigned int size = RARRAY(self)->len;
01762             temp1 = std::vector<int >(size);
01763             arg1 = &temp1;
01764             for (unsigned int i=0; i<size; i++) {
01765                 VALUE o = RARRAY(self)->ptr[i];
01766                 if (FIXNUM_P(o))
01767                 temp1[i] = (int)(FIX2INT(o));
01768                 else
01769                 rb_raise(rb_eTypeError,
01770                 "wrong argument type"
01771                 " (expected vector<""int" ">)");
01772             }
01773         } else {
01774             SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01775         }
01776     }
01777     {
01778         try {
01779             result = (bool)((std::vector<int > const *)arg1)->empty();
01780             
01781         } catch (const char *msg) {
01782             SWIG_exception(SWIG_RuntimeError, msg);
01783         }
01784     }
01785     vresult = result ? Qtrue : Qfalse;
01786     return vresult;
01787 }

static VALUE _wrap_IntVector_pop int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1831 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_int_Sg__pop(), SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01831                                                        {
01832     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01833     int result;
01834     VALUE vresult = Qnil;
01835     
01836     if ((argc < 0) || (argc > 0))
01837     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01838     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01839     {
01840         try {
01841             result = (int)std_vector_Sl_int_Sg__pop(arg1);
01842             
01843         } catch (std::out_of_range& e) {
01844             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01845         }
01846     }
01847     vresult = INT2NUM(result);
01848     return vresult;
01849 }

static VALUE _wrap_IntVector_push int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1810 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01810                                                         {
01811     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01812     int arg2 ;
01813     
01814     if ((argc < 1) || (argc > 1))
01815     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01816     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01817     arg2 = NUM2INT(argv[0]);
01818     {
01819         try {
01820             (arg1)->push_back(arg2);
01821             
01822         } catch (const char *msg) {
01823             SWIG_exception(SWIG_RuntimeError, msg);
01824         }
01825     }
01826     return Qnil;
01827 }

static VALUE _wrap_new_Condition int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2399 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by SWIGEXPORT().

02399                                                        {
02400     estraier::Condition *result;
02401     
02402     if ((argc < 0) || (argc > 0))
02403     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02404     {
02405         try {
02406             result = (estraier::Condition *)new estraier::Condition();
02407             DATA_PTR(self) = result;
02408         } catch (const char *msg) {
02409             SWIG_exception(SWIG_RuntimeError, msg);
02410         }
02411     }
02412     return self;
02413 }

static VALUE _wrap_new_Database int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2937 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by SWIGEXPORT().

02937                                                       {
02938     estraier::Database *result;
02939     
02940     if ((argc < 0) || (argc > 0))
02941     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02942     {
02943         try {
02944             result = (estraier::Database *)new estraier::Database();
02945             DATA_PTR(self) = result;
02946         } catch (const char *msg) {
02947             SWIG_exception(SWIG_RuntimeError, msg);
02948         }
02949     }
02950     return self;
02951 }

static VALUE _wrap_new_Document int  nargs,
VALUE *  args,
VALUE  self
[static]
 

Definition at line 2631 of file HyperEstraier_wrap.cxx.

References _wrap_new_Document__SWIG_0(), _wrap_new_Document__SWIG_1(), _wrap_new_Document__SWIG_2(), SWIG_ConvertPtr, and SWIGTYPE_p_ESTDOC.

Referenced by SWIGEXPORT().

02631                                                                     {
02632     int argc;
02633     VALUE argv[1];
02634     int ii;
02635     
02636     argc = nargs;
02637     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
02638         argv[ii] = args[ii];
02639     }
02640     if (argc == 0) {
02641         return _wrap_new_Document__SWIG_0(nargs, args, self);
02642     }
02643     if (argc == 1) {
02644         int _v;
02645         {
02646             void *ptr;
02647             _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_ESTDOC, 0) != -1)) ? 1 : 0;
02648         }
02649         if (_v) {
02650             return _wrap_new_Document__SWIG_2(nargs, args, self);
02651         }
02652     }
02653     if (argc == 1) {
02654         int _v;
02655         {
02656             _v = (TYPE(argv[0]) == T_STRING) ? 1 : 0;
02657         }
02658         if (_v) {
02659             return _wrap_new_Document__SWIG_1(nargs, args, self);
02660         }
02661     }
02662     
02663     rb_raise(rb_eArgError, "No matching function for overloaded 'new_Document'");
02664     return Qnil;
02665 }

static VALUE _wrap_new_Document__SWIG_0 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2557 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_Document(), and XS().

02557                                                               {
02558     estraier::Document *result;
02559     
02560     if ((argc < 0) || (argc > 0))
02561     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02562     {
02563         try {
02564             result = (estraier::Document *)new estraier::Document();
02565             DATA_PTR(self) = result;
02566         } catch (const char *msg) {
02567             SWIG_exception(SWIG_RuntimeError, msg);
02568         }
02569     }
02570     return self;
02571 }

static VALUE _wrap_new_Document__SWIG_1 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2575 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_Document(), and XS().

02575                                                               {
02576     char *arg1 = (char *) 0 ;
02577     estraier::Document *result;
02578     
02579     if ((argc < 1) || (argc > 1))
02580     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02581     arg1 = StringValuePtr(argv[0]);
02582     {
02583         try {
02584             result = (estraier::Document *)new estraier::Document((char const *)arg1);
02585             DATA_PTR(self) = result;
02586         } catch (const char *msg) {
02587             SWIG_exception(SWIG_RuntimeError, msg);
02588         }
02589     }
02590     return self;
02591 }

static VALUE _wrap_new_Document__SWIG_2 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2612 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_ESTDOC.

Referenced by _wrap_new_Document(), and XS().

02612                                                               {
02613     ESTDOC *arg1 = (ESTDOC *) 0 ;
02614     estraier::Document *result;
02615     
02616     if ((argc < 1) || (argc > 1))
02617     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02618     SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ESTDOC, 1);
02619     {
02620         try {
02621             result = (estraier::Document *)new estraier::Document(arg1);
02622             DATA_PTR(self) = result;
02623         } catch (const char *msg) {
02624             SWIG_exception(SWIG_RuntimeError, msg);
02625         }
02626     }
02627     return self;
02628 }

static VALUE _wrap_new_IntVector int  nargs,
VALUE *  args,
VALUE  self
[static]
 

Definition at line 1638 of file HyperEstraier_wrap.cxx.

References _wrap_new_IntVector__SWIG_0(), _wrap_new_IntVector__SWIG_1(), _wrap_new_IntVector__SWIG_2(), _wrap_new_IntVector__SWIG_3(), SWIG_ConvertPtr, and SWIGTYPE_p_std__vectorTint_t.

Referenced by SWIGEXPORT().

01638                                                                      {
01639     int argc;
01640     VALUE argv[2];
01641     int ii;
01642     
01643     argc = nargs;
01644     for (ii = 0; (ii < argc) && (ii < 2); ii++) {
01645         argv[ii] = args[ii];
01646     }
01647     if (argc == 0) {
01648         return _wrap_new_IntVector__SWIG_1(nargs, args, self);
01649     }
01650     if (argc == 1) {
01651         int _v;
01652         {
01653             _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
01654         }
01655         if (_v) {
01656             return _wrap_new_IntVector__SWIG_0(nargs, args, self);
01657         }
01658     }
01659     if (argc == 1) {
01660         int _v;
01661         {
01662             /* native sequence? */
01663             if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
01664                 unsigned int size = RARRAY(argv[0])->len;
01665                 if (size == 0) {
01666                     /* an empty sequence can be of any type */
01667                     _v = 1;
01668                 } else {
01669                     /* check the first element only */
01670                     VALUE o = RARRAY(argv[0])->ptr[0];
01671                     if (FIXNUM_P(o))
01672                     _v = 1;
01673                     else
01674                     _v = 0;
01675                 }
01676             } else {
01677                 /* wrapped vector? */
01678                 std::vector<int >* v;
01679                 if (SWIG_ConvertPtr(argv[0],(void **) &v, 
01680                 SWIGTYPE_p_std__vectorTint_t,0) != -1)
01681                 _v = 1;
01682                 else
01683                 _v = 0;
01684             }
01685         }
01686         if (_v) {
01687             return _wrap_new_IntVector__SWIG_3(nargs, args, self);
01688         }
01689     }
01690     if (argc == 2) {
01691         int _v;
01692         {
01693             _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
01694         }
01695         if (_v) {
01696             {
01697                 _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
01698             }
01699             if (_v) {
01700                 return _wrap_new_IntVector__SWIG_2(nargs, args, self);
01701             }
01702         }
01703     }
01704     
01705     rb_raise(rb_eArgError, "No matching function for overloaded 'new_IntVector'");
01706     return Qnil;
01707 }

static VALUE _wrap_new_IntVector__SWIG_0 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1522 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_IntVector(), and XS().

01522                                                                {
01523     unsigned int arg1 ;
01524     std::vector<int > *result;
01525     
01526     if ((argc < 1) || (argc > 1))
01527     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01528     arg1 = NUM2UINT(argv[0]);
01529     {
01530         try {
01531             result = (std::vector<int > *)new std::vector<int >(arg1);
01532             DATA_PTR(self) = result;
01533         } catch (const char *msg) {
01534             SWIG_exception(SWIG_RuntimeError, msg);
01535         }
01536     }
01537     return self;
01538 }

static VALUE _wrap_new_IntVector__SWIG_1 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1542 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_IntVector(), and XS().

01542                                                                {
01543     std::vector<int > *result;
01544     
01545     if ((argc < 0) || (argc > 0))
01546     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01547     {
01548         try {
01549             result = (std::vector<int > *)new std::vector<int >();
01550             DATA_PTR(self) = result;
01551         } catch (const char *msg) {
01552             SWIG_exception(SWIG_RuntimeError, msg);
01553         }
01554     }
01555     return self;
01556 }

static VALUE _wrap_new_IntVector__SWIG_2 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1560 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_IntVector(), and XS().

01560                                                                {
01561     unsigned int arg1 ;
01562     int *arg2 = 0 ;
01563     std::vector<int > *result;
01564     int temp2 ;
01565     
01566     if ((argc < 2) || (argc > 2))
01567     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
01568     arg1 = NUM2UINT(argv[0]);
01569     temp2 = (int) NUM2INT(argv[1]);
01570     arg2 = &temp2;
01571     {
01572         try {
01573             result = (std::vector<int > *)new std::vector<int >(arg1,(int const &)*arg2);
01574             DATA_PTR(self) = result;
01575         } catch (const char *msg) {
01576             SWIG_exception(SWIG_RuntimeError, msg);
01577         }
01578     }
01579     return self;
01580 }

static VALUE _wrap_new_IntVector__SWIG_3 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1601 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

Referenced by _wrap_new_IntVector(), and XS().

01601                                                                {
01602     std::vector<int > *arg1 = 0 ;
01603     std::vector<int > *result;
01604     std::vector<int > temp1 ;
01605     
01606     if ((argc < 1) || (argc > 1))
01607     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01608     {
01609         if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
01610             unsigned int size = RARRAY(argv[0])->len;
01611             temp1 = std::vector<int >(size);
01612             arg1 = &temp1;
01613             for (unsigned int i=0; i<size; i++) {
01614                 VALUE o = RARRAY(argv[0])->ptr[i];
01615                 if (FIXNUM_P(o))
01616                 temp1[i] = (int)(FIX2INT(o));
01617                 else
01618                 rb_raise(rb_eTypeError,
01619                 "wrong argument type"
01620                 " (expected vector<""int" ">)");
01621             }
01622         } else {
01623             SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_std__vectorTint_t, 1);
01624         }
01625     }
01626     {
01627         try {
01628             result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
01629             DATA_PTR(self) = result;
01630         } catch (const char *msg) {
01631             SWIG_exception(SWIG_RuntimeError, msg);
01632         }
01633     }
01634     return self;
01635 }

static VALUE _wrap_new_StrStrMap int  nargs,
VALUE *  args,
VALUE  self
[static]
 

Definition at line 1998 of file HyperEstraier_wrap.cxx.

References _wrap_new_StrStrMap__SWIG_0(), _wrap_new_StrStrMap__SWIG_1(), SWIG_ConvertPtr, SWIG_STRING_P(), and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

01998                                                                      {
01999     int argc;
02000     VALUE argv[1];
02001     int ii;
02002     
02003     argc = nargs;
02004     for (ii = 0; (ii < argc) && (ii < 1); ii++) {
02005         argv[ii] = args[ii];
02006     }
02007     if (argc == 0) {
02008         return _wrap_new_StrStrMap__SWIG_0(nargs, args, self);
02009     }
02010     if (argc == 1) {
02011         int _v;
02012         {
02013             // native sequence?
02014             if (rb_obj_is_kind_of(argv[0],rb_cHash)) {
02015                 VALUE keys = rb_funcall(argv[0],rb_intern("keys"),0);
02016                 unsigned int size = RARRAY(keys)->len;
02017                 if (size == 0) {
02018                     // an empty dictionary can be of any type
02019                     _v = 1;
02020                 } else {
02021                     // check the first element only
02022                     VALUE key = RARRAY(keys)->ptr[0];
02023                     VALUE val = rb_hash_aref(argv[0],key);
02024                     if (SWIG_STRING_P(key) && SWIG_STRING_P(val))
02025                     _v = 1;
02026                     else
02027                     _v = 0;
02028                 }
02029             } else {
02030                 // wrapped map?
02031                 std::map<std::string,std::string >* m;
02032                 if (SWIG_ConvertPtr(argv[0],(void **) &m,
02033                 SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
02034                 _v = 1;
02035                 else
02036                 _v = 0;
02037             }
02038         }
02039         if (_v) {
02040             return _wrap_new_StrStrMap__SWIG_1(nargs, args, self);
02041         }
02042     }
02043     
02044     rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrStrMap'");
02045     return Qnil;
02046 }

static VALUE _wrap_new_StrStrMap__SWIG_0 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1923 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_StrStrMap(), and XS().

01923                                                                {
01924     std::map<std::string,std::string > *result;
01925     
01926     if ((argc < 0) || (argc > 0))
01927     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01928     {
01929         try {
01930             result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
01931             DATA_PTR(self) = result;
01932         } catch (const char *msg) {
01933             SWIG_exception(SWIG_RuntimeError, msg);
01934         }
01935     }
01936     return self;
01937 }

static VALUE _wrap_new_StrStrMap__SWIG_1 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1958 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by _wrap_new_StrStrMap(), and XS().

01958                                                                {
01959     std::map<std::string,std::string > *arg1 = 0 ;
01960     std::map<std::string,std::string > *result;
01961     std::map<std::string,std::string > temp1 ;
01962     std::map<std::string,std::string > *m1 ;
01963     
01964     if ((argc < 1) || (argc > 1))
01965     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01966     {
01967         if (rb_obj_is_kind_of(argv[0],rb_cHash)) {
01968             temp1 = std::map<std::string,std::string >();
01969             arg1 = &temp1;
01970             VALUE keys = rb_funcall(argv[0],rb_intern("keys"),0);
01971             unsigned int size = RARRAY(keys)->len;
01972             for (unsigned int i=0; i<size; i++) {
01973                 VALUE key = RARRAY(keys)->ptr[i];
01974                 VALUE val = rb_hash_aref(argv[0],key);
01975                 if (!(SWIG_STRING_P(key) && SWIG_STRING_P(val)))
01976                 rb_raise(rb_eTypeError,
01977                 "wrong argument type"
01978                 " (expected map<""std::string" ",""std::string" ">)");
01979                 temp1[SWIG_RB2STR(key)] = SWIG_RB2STR(val);
01980             }
01981         } else {
01982             SWIG_ConvertPtr(argv[0],(void **) &m1, SWIGTYPE_p_std__mapTstd__string_std__string_t,1);
01983             arg1 = m1;
01984         }
01985     }
01986     {
01987         try {
01988             result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
01989             DATA_PTR(self) = result;
01990         } catch (const char *msg) {
01991             SWIG_exception(SWIG_RuntimeError, msg);
01992         }
01993     }
01994     return self;
01995 }

static VALUE _wrap_new_StrVector int  nargs,
VALUE *  args,
VALUE  self
[static]
 

Definition at line 1221 of file HyperEstraier_wrap.cxx.

References _wrap_new_StrVector__SWIG_0(), _wrap_new_StrVector__SWIG_1(), _wrap_new_StrVector__SWIG_2(), _wrap_new_StrVector__SWIG_3(), SWIG_ConvertPtr, SWIG_STRING_P(), and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01221                                                                      {
01222     int argc;
01223     VALUE argv[2];
01224     int ii;
01225     
01226     argc = nargs;
01227     for (ii = 0; (ii < argc) && (ii < 2); ii++) {
01228         argv[ii] = args[ii];
01229     }
01230     if (argc == 0) {
01231         return _wrap_new_StrVector__SWIG_1(nargs, args, self);
01232     }
01233     if (argc == 1) {
01234         int _v;
01235         {
01236             _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
01237         }
01238         if (_v) {
01239             return _wrap_new_StrVector__SWIG_0(nargs, args, self);
01240         }
01241     }
01242     if (argc == 1) {
01243         int _v;
01244         {
01245             /* native sequence? */
01246             if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
01247                 unsigned int size = RARRAY(argv[0])->len;
01248                 if (size == 0) {
01249                     /* an empty sequence can be of any type */
01250                     _v = 1;
01251                 } else {
01252                     /* check the first element only */
01253                     VALUE o = RARRAY(argv[0])->ptr[0];
01254                     if (SWIG_STRING_P(o))
01255                     _v = 1;
01256                     else
01257                     _v = 0;
01258                 }
01259             } else {
01260                 /* wrapped vector? */
01261                 std::vector<std::string >* v;
01262                 if (SWIG_ConvertPtr(argv[0],(void **) &v, 
01263                 SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
01264                 _v = 1;
01265                 else
01266                 _v = 0;
01267             }
01268         }
01269         if (_v) {
01270             return _wrap_new_StrVector__SWIG_3(nargs, args, self);
01271         }
01272     }
01273     if (argc == 2) {
01274         int _v;
01275         {
01276             _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
01277         }
01278         if (_v) {
01279             {
01280                 _v = (TYPE(argv[1]) == T_STRING) ? 1 : 0;
01281             }
01282             if (_v) {
01283                 return _wrap_new_StrVector__SWIG_2(nargs, args, self);
01284             }
01285         }
01286     }
01287     
01288     rb_raise(rb_eArgError, "No matching function for overloaded 'new_StrVector'");
01289     return Qnil;
01290 }

static VALUE _wrap_new_StrVector__SWIG_0 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1099 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_StrVector(), and XS().

01099                                                                {
01100     unsigned int arg1 ;
01101     std::vector<std::string > *result;
01102     
01103     if ((argc < 1) || (argc > 1))
01104     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01105     arg1 = NUM2UINT(argv[0]);
01106     {
01107         try {
01108             result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
01109             DATA_PTR(self) = result;
01110         } catch (const char *msg) {
01111             SWIG_exception(SWIG_RuntimeError, msg);
01112         }
01113     }
01114     return self;
01115 }

static VALUE _wrap_new_StrVector__SWIG_1 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1119 of file HyperEstraier_wrap.cxx.

References SWIG_exception, and SWIG_RuntimeError.

Referenced by _wrap_new_StrVector(), and XS().

01119                                                                {
01120     std::vector<std::string > *result;
01121     
01122     if ((argc < 0) || (argc > 0))
01123     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01124     {
01125         try {
01126             result = (std::vector<std::string > *)new std::vector<std::string >();
01127             DATA_PTR(self) = result;
01128         } catch (const char *msg) {
01129             SWIG_exception(SWIG_RuntimeError, msg);
01130         }
01131     }
01132     return self;
01133 }

static VALUE _wrap_new_StrVector__SWIG_2 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1137 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_exception, SWIG_RuntimeError, and SWIG_TypeError.

Referenced by _wrap_new_StrVector(), and XS().

01137                                                                {
01138     unsigned int arg1 ;
01139     std::string *arg2 = 0 ;
01140     std::vector<std::string > *result;
01141     std::string temp2 ;
01142     
01143     if ((argc < 2) || (argc > 2))
01144     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
01145     arg1 = NUM2UINT(argv[0]);
01146     {
01147         if (TYPE(argv[1]) == T_STRING) {
01148             temp2 = std::string(StringValuePtr(argv[1]));
01149             arg2 = &temp2;
01150         } else {
01151             SWIG_exception(SWIG_TypeError, "not a string");
01152         }
01153     }
01154     {
01155         try {
01156             result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
01157             DATA_PTR(self) = result;
01158         } catch (const char *msg) {
01159             SWIG_exception(SWIG_RuntimeError, msg);
01160         }
01161     }
01162     return self;
01163 }

static VALUE _wrap_new_StrVector__SWIG_3 int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1184 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by _wrap_new_StrVector(), and XS().

01184                                                                {
01185     std::vector<std::string > *arg1 = 0 ;
01186     std::vector<std::string > *result;
01187     std::vector<std::string > temp1 ;
01188     
01189     if ((argc < 1) || (argc > 1))
01190     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01191     {
01192         if (rb_obj_is_kind_of(argv[0],rb_cArray)) {
01193             unsigned int size = RARRAY(argv[0])->len;
01194             temp1 = std::vector<std::string >(size);
01195             arg1 = &temp1;
01196             for (unsigned int i=0; i<size; i++) {
01197                 VALUE o = RARRAY(argv[0])->ptr[i];
01198                 if (SWIG_STRING_P(o))
01199                 temp1[i] = (std::string)(SWIG_RB2STR(o));
01200                 else
01201                 rb_raise(rb_eTypeError,
01202                 "wrong argument type"
01203                 " (expected vector<""std::string" ">)");
01204             }
01205         } else {
01206             SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01207         }
01208     }
01209     {
01210         try {
01211             result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
01212             DATA_PTR(self) = result;
01213         } catch (const char *msg) {
01214             SWIG_exception(SWIG_RuntimeError, msg);
01215         }
01216     }
01217     return self;
01218 }

static VALUE _wrap_StrStrMap___getitem__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2155 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg____getitem__(), StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, SWIG_TypeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02155                                                                {
02156     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02157     std::string arg2 ;
02158     std::string result;
02159     VALUE vresult = Qnil;
02160     
02161     if ((argc < 1) || (argc > 1))
02162     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02163     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02164     {
02165         if (TYPE(argv[0]) == T_STRING) {
02166             arg2 = std::string(StringValuePtr(argv[0]));
02167         } else {
02168             SWIG_exception(SWIG_TypeError, "not a string");
02169         }
02170     }
02171     {
02172         try {
02173             result = std_map_Sl_std_string_Sc_std_string_Sg____getitem__(arg1,arg2);
02174             
02175         } catch (std::out_of_range& e) {
02176             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02177         }
02178     }
02179     {
02180         vresult = rb_str_new2((&result)->c_str());
02181     }
02182     return vresult;
02183 }

static VALUE _wrap_StrStrMap___len__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2050 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02050                                                            {
02051     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02052     unsigned int result;
02053     std::map<std::string,std::string > temp1 ;
02054     std::map<std::string,std::string > *m1 ;
02055     VALUE vresult = Qnil;
02056     
02057     if ((argc < 0) || (argc > 0))
02058     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02059     {
02060         if (rb_obj_is_kind_of(self,rb_cHash)) {
02061             temp1 = std::map<std::string,std::string >();
02062             arg1 = &temp1;
02063             VALUE keys = rb_funcall(self,rb_intern("keys"),0);
02064             unsigned int size = RARRAY(keys)->len;
02065             for (unsigned int i=0; i<size; i++) {
02066                 VALUE key = RARRAY(keys)->ptr[i];
02067                 VALUE val = rb_hash_aref(self,key);
02068                 if (!(SWIG_STRING_P(key) && SWIG_STRING_P(val)))
02069                 rb_raise(rb_eTypeError,
02070                 "wrong argument type"
02071                 " (expected map<""std::string" ",""std::string" ">)");
02072                 temp1[SWIG_RB2STR(key)] = SWIG_RB2STR(val);
02073             }
02074         } else {
02075             SWIG_ConvertPtr(self,(void **) &m1, SWIGTYPE_p_std__mapTstd__string_std__string_t,1);
02076             arg1 = m1;
02077         }
02078     }
02079     {
02080         try {
02081             result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
02082             
02083         } catch (const char *msg) {
02084             SWIG_exception(SWIG_RuntimeError, msg);
02085         }
02086     }
02087     vresult = UINT2NUM(result);
02088     return vresult;
02089 }

static VALUE _wrap_StrStrMap___setitem__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2187 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg____setitem__(), StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, SWIG_TypeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02187                                                                {
02188     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02189     std::string arg2 ;
02190     std::string arg3 ;
02191     
02192     if ((argc < 2) || (argc > 2))
02193     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
02194     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02195     {
02196         if (TYPE(argv[0]) == T_STRING) {
02197             arg2 = std::string(StringValuePtr(argv[0]));
02198         } else {
02199             SWIG_exception(SWIG_TypeError, "not a string");
02200         }
02201     }
02202     {
02203         if (TYPE(argv[1]) == T_STRING) {
02204             arg3 = std::string(StringValuePtr(argv[1]));
02205         } else {
02206             SWIG_exception(SWIG_TypeError, "not a string");
02207         }
02208     }
02209     {
02210         try {
02211             std_map_Sl_std_string_Sc_std_string_Sg____setitem__(arg1,arg2,arg3);
02212             
02213         } catch (const char *msg) {
02214             SWIG_exception(SWIG_RuntimeError, msg);
02215         }
02216     }
02217     return Qnil;
02218 }

static VALUE _wrap_StrStrMap_allocate int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1945 of file HyperEstraier_wrap.cxx.

References SWIG_NewClassInstance, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

01945                                                                 {
01946 #endif
01947         
01948         
01949         VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__mapTstd__string_std__string_t);
01950 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
01951         rb_obj_call_init(vresult, argc, argv);
01952 #endif
01953         return vresult;
01954     }

static VALUE _wrap_StrStrMap_clear int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2136 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02136                                                          {
02137     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02138     
02139     if ((argc < 0) || (argc > 0))
02140     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02141     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02142     {
02143         try {
02144             (arg1)->clear();
02145             
02146         } catch (const char *msg) {
02147             SWIG_exception(SWIG_RuntimeError, msg);
02148         }
02149     }
02150     return Qnil;
02151 }

static VALUE _wrap_StrStrMap_delete int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2222 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg____delitem__(), StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, SWIG_TypeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02222                                                           {
02223     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02224     std::string arg2 ;
02225     std::string result;
02226     VALUE vresult = Qnil;
02227     
02228     if ((argc < 1) || (argc > 1))
02229     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02230     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02231     {
02232         if (TYPE(argv[0]) == T_STRING) {
02233             arg2 = std::string(StringValuePtr(argv[0]));
02234         } else {
02235             SWIG_exception(SWIG_TypeError, "not a string");
02236         }
02237     }
02238     {
02239         try {
02240             result = std_map_Sl_std_string_Sc_std_string_Sg____delitem__(arg1,arg2);
02241             
02242         } catch (std::out_of_range& e) {
02243             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02244         }
02245     }
02246     {
02247         vresult = rb_str_new2((&result)->c_str());
02248     }
02249     return vresult;
02250 }

static VALUE _wrap_StrStrMap_each int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2328 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg__each(), SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02328                                                         {
02329     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02330     
02331     if ((argc < 0) || (argc > 0))
02332     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02333     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02334     {
02335         try {
02336             std_map_Sl_std_string_Sc_std_string_Sg__each(arg1);
02337             
02338         } catch (const char *msg) {
02339             SWIG_exception(SWIG_RuntimeError, msg);
02340         }
02341     }
02342     return Qnil;
02343 }

static VALUE _wrap_StrStrMap_emptyq___ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2093 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02093                                                              {
02094     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02095     bool result;
02096     std::map<std::string,std::string > temp1 ;
02097     std::map<std::string,std::string > *m1 ;
02098     VALUE vresult = Qnil;
02099     
02100     if ((argc < 0) || (argc > 0))
02101     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02102     {
02103         if (rb_obj_is_kind_of(self,rb_cHash)) {
02104             temp1 = std::map<std::string,std::string >();
02105             arg1 = &temp1;
02106             VALUE keys = rb_funcall(self,rb_intern("keys"),0);
02107             unsigned int size = RARRAY(keys)->len;
02108             for (unsigned int i=0; i<size; i++) {
02109                 VALUE key = RARRAY(keys)->ptr[i];
02110                 VALUE val = rb_hash_aref(self,key);
02111                 if (!(SWIG_STRING_P(key) && SWIG_STRING_P(val)))
02112                 rb_raise(rb_eTypeError,
02113                 "wrong argument type"
02114                 " (expected map<""std::string" ",""std::string" ">)");
02115                 temp1[SWIG_RB2STR(key)] = SWIG_RB2STR(val);
02116             }
02117         } else {
02118             SWIG_ConvertPtr(self,(void **) &m1, SWIGTYPE_p_std__mapTstd__string_std__string_t,1);
02119             arg1 = m1;
02120         }
02121     }
02122     {
02123         try {
02124             result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
02125             
02126         } catch (const char *msg) {
02127             SWIG_exception(SWIG_RuntimeError, msg);
02128         }
02129     }
02130     vresult = result ? Qtrue : Qfalse;
02131     return vresult;
02132 }

static VALUE _wrap_StrStrMap_has_keyq___ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2254 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg__has_key(), StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, SWIG_TypeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02254                                                                {
02255     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02256     std::string arg2 ;
02257     bool result;
02258     VALUE vresult = Qnil;
02259     
02260     if ((argc < 1) || (argc > 1))
02261     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
02262     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02263     {
02264         if (TYPE(argv[0]) == T_STRING) {
02265             arg2 = std::string(StringValuePtr(argv[0]));
02266         } else {
02267             SWIG_exception(SWIG_TypeError, "not a string");
02268         }
02269     }
02270     {
02271         try {
02272             result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key(arg1,arg2);
02273             
02274         } catch (const char *msg) {
02275             SWIG_exception(SWIG_RuntimeError, msg);
02276         }
02277     }
02278     vresult = result ? Qtrue : Qfalse;
02279     return vresult;
02280 }

static VALUE _wrap_StrStrMap_keys int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2284 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg__keys(), SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02284                                                         {
02285     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02286     VALUE result;
02287     VALUE vresult = Qnil;
02288     
02289     if ((argc < 0) || (argc > 0))
02290     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02291     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02292     {
02293         try {
02294             result = (VALUE)std_map_Sl_std_string_Sc_std_string_Sg__keys(arg1);
02295             
02296         } catch (const char *msg) {
02297             SWIG_exception(SWIG_RuntimeError, msg);
02298         }
02299     }
02300     vresult = result;
02301     return vresult;
02302 }

static VALUE _wrap_StrStrMap_values int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 2306 of file HyperEstraier_wrap.cxx.

References std_map_Sl_std_string_Sc_std_string_Sg__values(), SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

Referenced by SWIGEXPORT().

02306                                                           {
02307     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02308     VALUE result;
02309     VALUE vresult = Qnil;
02310     
02311     if ((argc < 0) || (argc > 0))
02312     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
02313     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
02314     {
02315         try {
02316             result = (VALUE)std_map_Sl_std_string_Sc_std_string_Sg__values(arg1);
02317             
02318         } catch (const char *msg) {
02319             SWIG_exception(SWIG_RuntimeError, msg);
02320         }
02321     }
02322     vresult = result;
02323     return vresult;
02324 }

static VALUE _wrap_StrVector___getitem__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1444 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_std_string_Sg____getitem__(), SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01444                                                                {
01445     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01446     int arg2 ;
01447     std::string result;
01448     VALUE vresult = Qnil;
01449     
01450     if ((argc < 1) || (argc > 1))
01451     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01452     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01453     arg2 = NUM2INT(argv[0]);
01454     {
01455         try {
01456             result = std_vector_Sl_std_string_Sg____getitem__(arg1,arg2);
01457             
01458         } catch (std::out_of_range& e) {
01459             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01460         }
01461     }
01462     {
01463         vresult = rb_str_new2((&result)->c_str());
01464     }
01465     return vresult;
01466 }

static VALUE _wrap_StrVector___len__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1294 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01294                                                            {
01295     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01296     unsigned int result;
01297     std::vector<std::string > temp1 ;
01298     VALUE vresult = Qnil;
01299     
01300     if ((argc < 0) || (argc > 0))
01301     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01302     {
01303         if (rb_obj_is_kind_of(self,rb_cArray)) {
01304             unsigned int size = RARRAY(self)->len;
01305             temp1 = std::vector<std::string >(size);
01306             arg1 = &temp1;
01307             for (unsigned int i=0; i<size; i++) {
01308                 VALUE o = RARRAY(self)->ptr[i];
01309                 if (SWIG_STRING_P(o))
01310                 temp1[i] = (std::string)(SWIG_RB2STR(o));
01311                 else
01312                 rb_raise(rb_eTypeError,
01313                 "wrong argument type"
01314                 " (expected vector<""std::string" ">)");
01315             }
01316         } else {
01317             SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01318         }
01319     }
01320     {
01321         try {
01322             result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
01323             
01324         } catch (const char *msg) {
01325             SWIG_exception(SWIG_RuntimeError, msg);
01326         }
01327     }
01328     vresult = UINT2NUM(result);
01329     return vresult;
01330 }

static VALUE _wrap_StrVector___setitem__ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1470 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_std_string_Sg____setitem__(), StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, SWIG_TypeError, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01470                                                                {
01471     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01472     int arg2 ;
01473     std::string arg3 ;
01474     
01475     if ((argc < 2) || (argc > 2))
01476     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
01477     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01478     arg2 = NUM2INT(argv[0]);
01479     {
01480         if (TYPE(argv[1]) == T_STRING) {
01481             arg3 = std::string(StringValuePtr(argv[1]));
01482         } else {
01483             SWIG_exception(SWIG_TypeError, "not a string");
01484         }
01485     }
01486     {
01487         try {
01488             std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);
01489             
01490         } catch (std::out_of_range& e) {
01491             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01492         }
01493     }
01494     return Qnil;
01495 }

static VALUE _wrap_StrVector_allocate int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1171 of file HyperEstraier_wrap.cxx.

References SWIG_NewClassInstance, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01171                                                                 {
01172 #endif
01173         
01174         
01175         VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorTstd__string_t);
01176 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
01177         rb_obj_call_init(vresult, argc, argv);
01178 #endif
01179         return vresult;
01180     }

static VALUE _wrap_StrVector_clear int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1374 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01374                                                          {
01375     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01376     
01377     if ((argc < 0) || (argc > 0))
01378     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01379     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01380     {
01381         try {
01382             (arg1)->clear();
01383             
01384         } catch (const char *msg) {
01385             SWIG_exception(SWIG_RuntimeError, msg);
01386         }
01387     }
01388     return Qnil;
01389 }

static VALUE _wrap_StrVector_each int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1499 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_std_string_Sg__each(), SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01499                                                         {
01500     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01501     
01502     if ((argc < 0) || (argc > 0))
01503     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01504     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01505     {
01506         try {
01507             std_vector_Sl_std_string_Sg__each(arg1);
01508             
01509         } catch (const char *msg) {
01510             SWIG_exception(SWIG_RuntimeError, msg);
01511         }
01512     }
01513     return Qnil;
01514 }

static VALUE _wrap_StrVector_emptyq___ int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1334 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, SWIG_exception, SWIG_RB2STR(), SWIG_RuntimeError, SWIG_STRING_P(), and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01334                                                              {
01335     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01336     bool result;
01337     std::vector<std::string > temp1 ;
01338     VALUE vresult = Qnil;
01339     
01340     if ((argc < 0) || (argc > 0))
01341     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01342     {
01343         if (rb_obj_is_kind_of(self,rb_cArray)) {
01344             unsigned int size = RARRAY(self)->len;
01345             temp1 = std::vector<std::string >(size);
01346             arg1 = &temp1;
01347             for (unsigned int i=0; i<size; i++) {
01348                 VALUE o = RARRAY(self)->ptr[i];
01349                 if (SWIG_STRING_P(o))
01350                 temp1[i] = (std::string)(SWIG_RB2STR(o));
01351                 else
01352                 rb_raise(rb_eTypeError,
01353                 "wrong argument type"
01354                 " (expected vector<""std::string" ">)");
01355             }
01356         } else {
01357             SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01358         }
01359     }
01360     {
01361         try {
01362             result = (bool)((std::vector<std::string > const *)arg1)->empty();
01363             
01364         } catch (const char *msg) {
01365             SWIG_exception(SWIG_RuntimeError, msg);
01366         }
01367     }
01368     vresult = result ? Qtrue : Qfalse;
01369     return vresult;
01370 }

static VALUE _wrap_StrVector_pop int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1420 of file HyperEstraier_wrap.cxx.

References std_vector_Sl_std_string_Sg__pop(), SWIG_ConvertPtr, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01420                                                        {
01421     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01422     std::string result;
01423     VALUE vresult = Qnil;
01424     
01425     if ((argc < 0) || (argc > 0))
01426     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
01427     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01428     {
01429         try {
01430             result = std_vector_Sl_std_string_Sg__pop(arg1);
01431             
01432         } catch (std::out_of_range& e) {
01433             SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01434         }
01435     }
01436     {
01437         vresult = rb_str_new2((&result)->c_str());
01438     }
01439     return vresult;
01440 }

static VALUE _wrap_StrVector_push int  argc,
VALUE *  argv,
VALUE  self
[static]
 

Definition at line 1393 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_ConvertPtr, SWIG_exception, SWIG_RuntimeError, SWIG_TypeError, and SWIGTYPE_p_std__vectorTstd__string_t.

Referenced by SWIGEXPORT().

01393                                                         {
01394     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01395     std::string arg2 ;
01396     
01397     if ((argc < 1) || (argc > 1))
01398     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
01399     SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t, 1);
01400     {
01401         if (TYPE(argv[0]) == T_STRING) {
01402             arg2 = std::string(StringValuePtr(argv[0]));
01403         } else {
01404             SWIG_exception(SWIG_TypeError, "not a string");
01405         }
01406     }
01407     {
01408         try {
01409             (arg1)->push_back(arg2);
01410             
01411         } catch (const char *msg) {
01412             SWIG_exception(SWIG_RuntimeError, msg);
01413         }
01414     }
01415     return Qnil;
01416 }

static void free_estraier_Condition estraier::Condition  )  [static]
 

Definition at line 2417 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

02417                                                  {
02418     delete arg1;
02419 }

static void free_estraier_Database estraier::Database  )  [static]
 

Definition at line 2955 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

02955                                                {
02956     delete arg1;
02957 }

static void free_estraier_Document estraier::Document  )  [static]
 

Definition at line 2669 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

02669                                                {
02670     delete arg1;
02671 }

static void free_std_map_Sl_std_string_Sc_std_string_Sg_ std::map< std::string, std::string > *   )  [static]
 

Definition at line 2347 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

02347                                                                                  {
02348     delete arg1;
02349 }

static void free_std_vector_Sl_int_Sg_ std::vector< int > *   )  [static]
 

Definition at line 1919 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

01919                                                   {
01920     delete arg1;
01921 }

static void free_std_vector_Sl_std_string_Sg_ std::vector< std::string > *   )  [static]
 

Definition at line 1518 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

01518                                                                {
01519     delete arg1;
01520 }

static std::string std_map_Sl_std_string_Sc_std_string_Sg____delitem__ std::map< std::string, std::string > *  self,
std::string  key
[static]
 

Definition at line 1041 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_StrStrMap_delete().

01041                                                                                                                       {
01042                 std::map<std::string,std::string >::iterator i = self->find(key);
01043                 if (i != self->end()) {
01044                     std::string x = i->second;
01045                     self->erase(i);
01046                     return x;
01047                 } else
01048                     throw std::out_of_range("key not found");
01049             }

static std::string std_map_Sl_std_string_Sc_std_string_Sg____getitem__ std::map< std::string, std::string > *  self,
std::string  key
[static]
 

Definition at line 1031 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_StrStrMap___getitem__().

01031                                                                                                                       {
01032                 std::map<std::string,std::string >::iterator i = self->find(key);
01033                 if (i != self->end())
01034                     return i->second;
01035                 else
01036                     throw std::out_of_range("key not found");
01037             }

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
[static]
 

Definition at line 1038 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_StrStrMap___setitem__().

01038                                                                                                                              {
01039                 (*self)[key] = x;
01040             }

static void std_map_Sl_std_string_Sc_std_string_Sg__each std::map< std::string, std::string > *  self  )  [static]
 

Definition at line 1074 of file HyperEstraier_wrap.cxx.

References SWIG_STR2RB().

Referenced by _wrap_StrStrMap_each().

01074                                                                                             {
01075                 std::map<std::string,std::string >::iterator i;
01076                 for (i=self->begin(); i!=self->end(); ++i) {
01077                     VALUE entry = rb_ary_new2(2);
01078                     rb_ary_store(entry,0,SWIG_STR2RB(i->first));
01079                     rb_ary_store(entry,1,SWIG_STR2RB(i->second));
01080                     rb_yield(entry);
01081                 }
01082             }

static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key std::map< std::string, std::string > *  self,
std::string  key
[static]
 

Definition at line 1050 of file HyperEstraier_wrap.cxx.

01050                                                                                                              {
01051                 std::map<std::string,std::string >::iterator i = self->find(key);
01052                 return i != self->end();
01053             }

static VALUE std_map_Sl_std_string_Sc_std_string_Sg__keys std::map< std::string, std::string > *  self  )  [static]
 

Definition at line 1054 of file HyperEstraier_wrap.cxx.

References SWIG_STR2RB().

Referenced by _wrap_StrStrMap_keys().

01054                                                                                              {
01055                 VALUE keyList = rb_ary_new2(self->size());
01056                 std::map<std::string,std::string >::iterator i;
01057                 unsigned int j;
01058                 for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
01059                     rb_ary_store(keyList,j,
01060                                  SWIG_STR2RB(i->first));
01061                 }
01062                 return keyList;
01063             }

static VALUE std_map_Sl_std_string_Sc_std_string_Sg__values std::map< std::string, std::string > *  self  )  [static]
 

Definition at line 1064 of file HyperEstraier_wrap.cxx.

References SWIG_STR2RB().

Referenced by _wrap_StrStrMap_values().

01064                                                                                                {
01065                 VALUE valueList = rb_ary_new2(self->size());
01066                 std::map<std::string,std::string >::iterator i;
01067                 unsigned int j;
01068                 for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
01069                     rb_ary_store(valueList,j,
01070                                  SWIG_STR2RB(i->second));
01071                 }
01072                 return valueList;
01073             }

static int std_vector_Sl_int_Sg____getitem__ std::vector< int > *  self,
int  i
[static]
 

Definition at line 1008 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_IntVector___getitem__().

01008                                                                          {
01009                 int size = int(self->size());
01010                 if (i<0) i += size;
01011                 if (i>=0 && i<size)
01012                     return (*self)[i];
01013                 else
01014                     throw std::out_of_range("vector index out of range");
01015             }

static void std_vector_Sl_int_Sg____setitem__ std::vector< int > *  self,
int  i,
int  x
[static]
 

Definition at line 1016 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_IntVector___setitem__().

01016                                                                                 {
01017                 int size = int(self->size());
01018                 if (i<0) i+= size;
01019                 if (i>=0 && i<size)
01020                     (*self)[i] = x;
01021                 else
01022                     throw std::out_of_range("vector index out of range");
01023             }

static void std_vector_Sl_int_Sg__each std::vector< int > *  self  )  [static]
 

Definition at line 1024 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_IntVector_each().

01024                                                              {
01025                 for (unsigned int i=0; i<self->size(); i++)
01026                     rb_yield(INT2NUM((*self)[i]));
01027             }

static int std_vector_Sl_int_Sg__pop std::vector< int > *  self  )  [static]
 

Definition at line 1001 of file HyperEstraier_wrap.cxx.

01001                                                            {
01002                 if (self->size() == 0)
01003                     throw std::out_of_range("pop from empty vector");
01004                 int x = self->back();
01005                 self->pop_back();
01006                 return x;
01007             }

static std::string std_vector_Sl_std_string_Sg____getitem__ std::vector< std::string > *  self,
int  i
[static]
 

Definition at line 978 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_StrVector___getitem__().

00978                                                                                             {
00979                 int size = int(self->size());
00980                 if (i<0) i += size;
00981                 if (i>=0 && i<size)
00982                     return (*self)[i];
00983                 else
00984                     throw std::out_of_range("vector index out of range");
00985             }

static void std_vector_Sl_std_string_Sg____setitem__ std::vector< std::string > *  self,
int  i,
std::string  x
[static]
 

Definition at line 986 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_StrVector___setitem__().

00986                                                                                                    {
00987                 int size = int(self->size());
00988                 if (i<0) i+= size;
00989                 if (i>=0 && i<size)
00990                     (*self)[i] = x;
00991                 else
00992                     throw std::out_of_range("vector index out of range");
00993             }

static void std_vector_Sl_std_string_Sg__each std::vector< std::string > *  self  )  [static]
 

Definition at line 994 of file HyperEstraier_wrap.cxx.

References SWIG_STR2RB().

Referenced by _wrap_StrVector_each().

00994                                                                           {
00995                 for (unsigned int i=0; i<self->size(); i++)
00996                     rb_yield(SWIG_STR2RB((*self)[i]));
00997             }

static std::string std_vector_Sl_std_string_Sg__pop std::vector< std::string > *  self  )  [static]
 

Definition at line 971 of file HyperEstraier_wrap.cxx.

00971                                                                               {
00972                 if (self->size() == 0)
00973                     throw std::out_of_range("pop from empty vector");
00974                 std::string x = self->back();
00975                 self->pop_back();
00976                 return x;
00977             }

static void SWIG_AsVal VALUE  obj,
int *  val
[static]
 

Definition at line 863 of file HyperEstraier_wrap.cxx.

00864 {
00865     *val = (int) NUM2INT(obj);
00866 }

VALUE SWIG_BOOL2RB bool  b  ) 
 

Definition at line 939 of file HyperEstraier_wrap.cxx.

00939                            {
00940     return b ? Qtrue : Qfalse;
00941 }

bool SWIG_BOOL_P VALUE   ) 
 

Definition at line 932 of file HyperEstraier_wrap.cxx.

00932                         {
00933     // dummy test, RTEST should take care of everything
00934     return true;
00935 }

static void SWIG_exception_ int  code,
const char *  msg
[static]
 

Definition at line 882 of file HyperEstraier_wrap.cxx.

References SWIG_DivisionByZero, SWIG_IndexError, SWIG_IOError, SWIG_MemoryError, SWIG_OverflowError, SWIG_RuntimeError, SWIG_SyntaxError, SWIG_SystemError, SWIG_TypeError, SWIG_UnknownError, and SWIG_ValueError.

00882                                                        {
00883     switch (code) {
00884         case SWIG_MemoryError:
00885             rb_raise(rb_eNoMemError, msg);
00886             break;
00887         case SWIG_IOError:
00888             rb_raise(rb_eIOError, msg);
00889             break;
00890         case SWIG_RuntimeError:
00891             rb_raise(rb_eRuntimeError, msg);
00892             break;
00893         case SWIG_IndexError:
00894             rb_raise(rb_eIndexError, msg);
00895             break;
00896         case SWIG_TypeError:
00897             rb_raise(rb_eTypeError, msg);
00898             break;
00899         case SWIG_DivisionByZero:
00900             rb_raise(rb_eZeroDivError, msg);
00901             break;
00902         case SWIG_OverflowError:
00903             rb_raise(rb_eRangeError, msg);
00904             break;
00905         case SWIG_SyntaxError:
00906             rb_raise(rb_eSyntaxError, msg);
00907             break;
00908         case SWIG_ValueError:
00909             rb_raise(rb_eArgError, msg);
00910             break;
00911         case SWIG_SystemError:
00912             rb_raise(rb_eFatal, msg);
00913             break;
00914         case SWIG_UnknownError:
00915             rb_raise(rb_eRuntimeError, msg);
00916             break;
00917         default:
00918             break;
00919     }
00920 }

double SWIG_NUM2DBL VALUE  x  ) 
 

Definition at line 942 of file HyperEstraier_wrap.cxx.

00942                              {
00943     return (FIXNUM_P(x) ? FIX2INT(x) : NUM2DBL(x));
00944 }

SWIGRUNTIME char* SWIG_PackData char *  c,
void *  ptr,
size_t  sz
 

Definition at line 423 of file HyperEstraier_wrap.cxx.

00423                                              {
00424   static char hex[17] = "0123456789abcdef";
00425   unsigned char *u = (unsigned char *) ptr;
00426   const unsigned char *eu =  u + sz;
00427   register unsigned char uu;
00428   for (; u != eu; ++u) {
00429     uu = *u;
00430     *(c++) = hex[(uu & 0xf0) >> 4];
00431     *(c++) = hex[uu & 0xf];
00432   }
00433   return c;
00434 }

SWIGRUNTIME char* SWIG_PackDataName char *  buff,
void *  ptr,
size_t  sz,
const char *  name,
size_t  bsz
 

Definition at line 516 of file HyperEstraier_wrap.cxx.

References SWIG_PackData().

00516                                                                                   {
00517   char *r = buff;
00518   size_t lname = (name ? strlen(name) : 0);
00519   if ((2*sz + 2 + lname) > bsz) return 0;
00520   *(r++) = '_';
00521   r = SWIG_PackData(r,ptr,sz);
00522   if (lname) {
00523     strncpy(r,name,lname+1);
00524   } else {
00525     *r = 0;
00526   }
00527   return buff;
00528 }

SWIGRUNTIME char* SWIG_PackVoidPtr char *  buff,
void *  ptr,
const char *  name,
size_t  bsz
 

Definition at line 492 of file HyperEstraier_wrap.cxx.

References SWIG_PackData().

00492                                                                       {
00493   char *r = buff;
00494   if ((2*sizeof(void *) + 2) > bsz) return 0;
00495   *(r++) = '_';
00496   r = SWIG_PackData(r,&ptr,sizeof(void *));
00497   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00498   strcpy(r,name);
00499   return buff;
00500 }

static void SWIG_PropagateClientData swig_type_info type  )  [static]
 

Definition at line 611 of file HyperEstraier_wrap.cxx.

References SWIG_PropagateClientDataTL().

00611                                                {
00612   SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
00613 }

SWIGRUNTIME void SWIG_PropagateClientDataTL swig_type_info tl,
swig_type_info type
 

Definition at line 471 of file HyperEstraier_wrap.cxx.

References swig_type_info::clientdata, swig_type_info::converter, swig_type_info::name, swig_type_info::next, swig_type_info::prev, and SWIG_TypeClientDataTL().

00471                                                                      {
00472   swig_type_info *equiv = type->next;
00473   swig_type_info *tc;
00474   if (!type->clientdata) return;
00475   while (equiv) {
00476     if (!equiv->converter) {
00477       tc = tl;
00478       while (tc) {
00479         if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
00480           SWIG_TypeClientDataTL(tl,tc, type->clientdata);
00481         tc = tc->prev;
00482       }
00483     }
00484     equiv = equiv->next;
00485   }
00486 }

bool SWIG_RB2BOOL VALUE  x  ) 
 

Definition at line 936 of file HyperEstraier_wrap.cxx.

00936                            {
00937     return RTEST(x);
00938 }

std::string SWIG_RB2STR VALUE  x  ) 
 

Definition at line 948 of file HyperEstraier_wrap.cxx.

References StringValuePtr.

Referenced by _wrap_Document_make_snippet(), _wrap_new_StrStrMap__SWIG_1(), _wrap_new_StrVector__SWIG_3(), _wrap_StrStrMap___len__(), _wrap_StrStrMap_emptyq___(), _wrap_StrVector___len__(), and _wrap_StrVector_emptyq___().

00948                                {
00949     return std::string(StringValuePtr(x));
00950 }

static SWIGINLINE int SWIG_Ruby_CheckConvert VALUE  obj,
swig_type_info ty
[static]
 

Definition at line 789 of file HyperEstraier_wrap.cxx.

References SWIG_MangleStr, and SWIG_TypeCheck().

00790 {
00791   char *c = SWIG_MangleStr(obj);
00792   if (!c)
00793     return 0;
00794   return SWIG_TypeCheck(c,ty) != 0;
00795 }

static void SWIG_Ruby_ConvertPacked VALUE  obj,
void *  ptr,
int  sz,
swig_type_info ty,
int  flags
[static]
 

Definition at line 810 of file HyperEstraier_wrap.cxx.

References StringValuePtr, SWIG_TypeCheck(), and SWIG_UnpackData().

00810                                                                                      {
00811   swig_type_info *tc;
00812   const char  *c;
00813 
00814   if (TYPE(obj) != T_STRING) goto type_error;
00815   c = StringValuePtr(obj);
00816   /* Pointer values must start with leading underscore */
00817   if (*c != '_') goto type_error;
00818   c++;
00819   c = SWIG_UnpackData(c, ptr, sz);
00820   if (ty) {
00821     tc = SWIG_TypeCheck(c, ty);
00822     if (!tc) goto type_error;
00823   }
00824   return;
00825 
00826 type_error:
00827 
00828   if (flags) {
00829     if (ty) {
00830       rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name);
00831     } else {
00832       rb_raise(rb_eTypeError, "Expected a pointer");
00833     }
00834   }
00835 }

static int SWIG_Ruby_ConvertPtr VALUE  obj,
void **  ptr,
swig_type_info ty,
int  flags
[static]
 

Definition at line 738 of file HyperEstraier_wrap.cxx.

References swig_type_info::clientdata, swig_type_info::str, SWIG_MangleStr, SWIG_POINTER_EXCEPTION, SWIG_TypeCast(), and SWIG_TypeCheck().

00739 {
00740   char *c;
00741   swig_type_info *tc;
00742 
00743   /* Grab the pointer */
00744   if (NIL_P(obj)) {
00745     *ptr = 0;
00746     return 0;
00747   } else {
00748     Data_Get_Struct(obj, void, *ptr);
00749   }
00750   
00751   /* Do type-checking if type info was provided */
00752   if (ty) {
00753     if (ty->clientdata) {
00754         if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
00755           if (*ptr == 0)
00756             rb_raise(rb_eRuntimeError, "This %s already released", ty->str);
00757           return 0;
00758         }
00759     }
00760     if ((c = SWIG_MangleStr(obj)) == NULL) {
00761       if (flags & SWIG_POINTER_EXCEPTION)
00762         rb_raise(rb_eTypeError, "Expected %s", ty->str);
00763       else
00764         return -1;
00765     }
00766     tc = SWIG_TypeCheck(c, ty);
00767     if (!tc) {
00768       if (flags & SWIG_POINTER_EXCEPTION)
00769         rb_raise(rb_eTypeError, "Expected %s", ty->str);
00770       else
00771         return -1;
00772     }
00773     *ptr = SWIG_TypeCast(tc, *ptr);
00774   }
00775   return 0;
00776 }

static void SWIG_Ruby_define_class swig_type_info type  )  [static]
 

Definition at line 678 of file HyperEstraier_wrap.cxx.

References swig_type_info::name.

00679 {
00680     VALUE klass;
00681     char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
00682     sprintf(klass_name, "TYPE%s", type->name);
00683     if (NIL_P(_cSWIG_Pointer)) {
00684     _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
00685     rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
00686     }
00687     klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
00688     free((void *) klass_name);
00689 }

static void SWIG_Ruby_InitRuntime void   )  [static]
 

Definition at line 655 of file HyperEstraier_wrap.cxx.

References SWIG_RUNTIME_VERSION, swig_type_list_handle, and SWIG_TYPE_TABLE_NAME.

00656 {
00657     VALUE pointer;
00658     
00659     if (_mSWIG == Qnil) {
00660         _mSWIG = rb_define_module("SWIG");
00661     }
00662     
00663     /* first check if pointer already created */
00664     pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
00665     if (pointer != Qnil) {
00666       Data_Get_Struct(pointer, swig_type_info *, swig_type_list_handle);
00667     } else {
00668       /* register a new class */
00669       VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
00670       /* create and store the structure pointer to a global variable */
00671       swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, swig_type_list_handle);
00672       rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
00673     }
00674 }

static SWIGINLINE char* SWIG_Ruby_MangleStr VALUE  obj  )  [static]
 

Definition at line 730 of file HyperEstraier_wrap.cxx.

References StringValuePtr.

00731 {
00732   VALUE stype = rb_iv_get(obj, "__swigtype__");
00733   return StringValuePtr(stype);
00734 }

static SWIGINLINE void* SWIG_Ruby_MustGetPtr VALUE  obj,
swig_type_info ty,
int  argnum,
int  flags
[static]
 

Definition at line 780 of file HyperEstraier_wrap.cxx.

References SWIG_ConvertPtr, and SWIG_POINTER_EXCEPTION.

00781 {
00782   void *result;
00783   SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
00784   return result;
00785 }

static VALUE SWIG_Ruby_NewClassInstance VALUE  klass,
swig_type_info type
[static]
 

Definition at line 719 of file HyperEstraier_wrap.cxx.

References swig_type_info::clientdata, swig_class::destroy, swig_class::mark, swig_type_info::name, and VOIDFUNC.

00720 {
00721     VALUE obj;
00722     swig_class *sklass = (swig_class *) type->clientdata;
00723     obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
00724     rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
00725     return obj;
00726 }

static VALUE SWIG_Ruby_NewPackedObj void *  ptr,
int  sz,
swig_type_info type
[static]
 

Definition at line 798 of file HyperEstraier_wrap.cxx.

References swig_type_info::name, and SWIG_PackData().

00798                                                                 {
00799   char result[1024];
00800   char *r = result;
00801   if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
00802   *(r++) = '_';
00803   r = SWIG_PackData(r, ptr, sz);
00804   strcpy(r, type->name);
00805   return rb_str_new2(result);
00806 }

static VALUE SWIG_Ruby_NewPointerObj void *  ptr,
swig_type_info type,
int  own
[static]
 

Definition at line 693 of file HyperEstraier_wrap.cxx.

References swig_type_info::clientdata, swig_class::destroy, swig_class::klass, swig_class::mark, swig_type_info::name, and VOIDFUNC.

00694 {
00695     char *klass_name;
00696     swig_class *sklass;
00697     VALUE klass;
00698     VALUE obj;
00699     
00700     if (!ptr)
00701     return Qnil;
00702     
00703     if (type->clientdata) {
00704       sklass = (swig_class *) type->clientdata;
00705       obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
00706     } else {
00707       klass_name = (char *) malloc(4 + strlen(type->name) + 1);
00708       sprintf(klass_name, "TYPE%s", type->name);
00709       klass = rb_const_get(_mSWIG, rb_intern(klass_name));
00710       free((void *) klass_name);
00711       obj = Data_Wrap_Struct(klass, 0, 0, ptr);
00712     }
00713     rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
00714     return obj;
00715 }

VALUE SWIG_STR2RB const std::string &  s  ) 
 

Definition at line 951 of file HyperEstraier_wrap.cxx.

Referenced by std_map_Sl_std_string_Sc_std_string_Sg__each(), std_map_Sl_std_string_Sc_std_string_Sg__keys(), std_map_Sl_std_string_Sc_std_string_Sg__values(), and std_vector_Sl_std_string_Sg__each().

00951                                       {
00952     return rb_str_new2(s.c_str());
00953 }

bool SWIG_STRING_P VALUE  x  ) 
 

Definition at line 945 of file HyperEstraier_wrap.cxx.

Referenced by _wrap_Document_make_snippet(), _wrap_new_StrStrMap(), _wrap_new_StrStrMap__SWIG_1(), _wrap_new_StrVector(), _wrap_new_StrVector__SWIG_3(), _wrap_StrStrMap___len__(), _wrap_StrStrMap_emptyq___(), _wrap_StrVector___len__(), and _wrap_StrVector_emptyq___().

00945                             {
00946     return TYPE(x) == T_STRING;
00947 }

SWIGRUNTIMEINLINE void* SWIG_TypeCast swig_type_info ty,
void *  ptr
 

Definition at line 335 of file HyperEstraier_wrap.cxx.

References swig_type_info::converter.

00335                                              {
00336   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
00337 }

SWIGRUNTIME swig_type_info* SWIG_TypeCheck const char *  c,
swig_type_info ty
 

Definition at line 307 of file HyperEstraier_wrap.cxx.

References swig_type_info::name, swig_type_info::next, and swig_type_info::prev.

00307                                                   {
00308   swig_type_info *s;
00309   if (!ty) return 0;        /* Void pointer */
00310   s = ty->next;             /* First element always just a name */
00311   do {
00312     if (strcmp(s->name,c) == 0) {
00313       if (s == ty->next) return s;
00314       /* Move s to the top of the linked list */
00315       s->prev->next = s->next;
00316       if (s->next) {
00317         s->next->prev = s->prev;
00318       }
00319       /* Insert s as second element in the list */
00320       s->next = ty->next;
00321       if (ty->next) ty->next->prev = s;
00322       ty->next = s;
00323       s->prev = ty;
00324       return s;
00325     }
00326     s = s->next;
00327   } while (s && (s != ty->next));
00328   return 0;
00329 }

static void SWIG_TypeClientData swig_type_info ti,
void *  clientdata
[static]
 

Definition at line 601 of file HyperEstraier_wrap.cxx.

References SWIG_TypeClientDataTL().

00601                                                           {
00602   SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
00603 }

SWIGRUNTIME void SWIG_TypeClientDataTL swig_type_info tl,
swig_type_info ti,
void *  clientdata
 

Definition at line 400 of file HyperEstraier_wrap.cxx.

References swig_type_info::clientdata, swig_type_info::converter, swig_type_info::name, swig_type_info::next, swig_type_info::prev, and SWIG_TypeClientDataTL().

00400                                                                                 {
00401   swig_type_info *tc, *equiv;
00402   if (ti->clientdata) return;
00403   /* if (ti->clientdata == clientdata) return; */
00404   ti->clientdata = clientdata;
00405   equiv = ti->next;
00406   while (equiv) {
00407     if (!equiv->converter) {
00408       tc = tl;
00409       while (tc) {
00410         if ((strcmp(tc->name, equiv->name) == 0))
00411           SWIG_TypeClientDataTL(tl,tc,clientdata);
00412         tc = tc->prev;
00413       }
00414     }
00415     equiv = equiv->next;
00416   }
00417 }

SWIGRUNTIME swig_type_info* SWIG_TypeDynamicCast swig_type_info ty,
void **  ptr
 

Definition at line 343 of file HyperEstraier_wrap.cxx.

References swig_type_info::dcast.

00343                                                      {
00344   swig_type_info *lastty = ty;
00345   if (!ty || !ty->dcast) return ty;
00346   while (ty && (ty->dcast)) {
00347     ty = (*ty->dcast)(ptr);
00348     if (ty) lastty = ty;
00349   }
00350   return lastty;
00351 }

SWIGRUNTIME int SWIG_TypeEquiv const char *  nb,
const char *  tb
 

Definition at line 238 of file HyperEstraier_wrap.cxx.

References SWIG_TypeNameComp().

00238                                                {
00239   int equiv = 0;
00240   const char* te = tb + strlen(tb);
00241   const char* ne = nb;
00242   while (!equiv && *ne) {
00243     for (nb = ne; *ne; ++ne) {
00244       if (*ne == '|') break;
00245     }
00246     equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
00247     if (*ne) ++ne;
00248   }
00249   return equiv;
00250 }

SWIGRUNTIMEINLINE const char* SWIG_TypeName const swig_type_info ty  ) 
 

Definition at line 357 of file HyperEstraier_wrap.cxx.

References swig_type_info::name.

00357                                         {
00358   return ty->name;
00359 }

SWIGRUNTIME int SWIG_TypeNameComp const char *  f1,
const char *  l1,
const char *  f2,
const char *  l2
 

Definition at line 224 of file HyperEstraier_wrap.cxx.

00225                                           {
00226   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00227     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00228     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00229     if (*f1 != *f2) return *f1 - *f2;
00230   }
00231   return (l1 - f1) - (l2 - f2);
00232 }

SWIGRUNTIME const char* SWIG_TypePrettyName const swig_type_info type  ) 
 

Definition at line 366 of file HyperEstraier_wrap.cxx.

References swig_type_info::name, and swig_type_info::str.

00366                                                 {
00367   /* The "str" field contains the equivalent pretty names of the
00368      type, separated by vertical-bar characters.  We choose
00369      to print the last name, as it is often (?) the most
00370      specific. */
00371   if (type->str != NULL) {
00372     const char *last_name = type->str;
00373     const char *s;
00374     for (s = type->str; *s; s++)
00375       if (*s == '|') last_name = s+1;
00376     return last_name;
00377   }
00378   else
00379     return type->name;
00380 }

static swig_type_info* SWIG_TypeQuery const char *  name  )  [static]
 

Definition at line 595 of file HyperEstraier_wrap.cxx.

References SWIG_TypeQueryTL().

00595                                  {
00596   return SWIG_TypeQueryTL(*swig_type_list_handle, name);
00597 }

SWIGRUNTIME swig_type_info* SWIG_TypeQueryTL swig_type_info tl,
const char *  name
 

Definition at line 386 of file HyperEstraier_wrap.cxx.

References swig_type_info::name, swig_type_info::prev, swig_type_info::str, and SWIG_TypeEquiv().

00386                                                        {
00387   swig_type_info *ty = tl;
00388   while (ty) {
00389     if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
00390     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
00391     ty = ty->prev;
00392   }
00393   return 0;
00394 }

static swig_type_info* SWIG_TypeRegister swig_type_info ti  )  [static]
 

Definition at line 589 of file HyperEstraier_wrap.cxx.

References SWIG_TypeRegisterTL().

00589                                       {
00590   return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
00591 }

SWIGRUNTIME swig_type_info* SWIG_TypeRegisterTL swig_type_info **  tl,
swig_type_info ti
 

Definition at line 256 of file HyperEstraier_wrap.cxx.

References swig_type_info::clientdata, swig_type_info::name, swig_type_info::next, swig_type_info::prev, swig_type_info::str, and SWIG_TypeEquiv().

00256                                                              {
00257   swig_type_info *tc, *head, *ret, *next;
00258   /* Check to see if this type has already been registered */
00259   tc = *tl;
00260   while (tc) {
00261     /* check simple type equivalence */
00262     int typeequiv = (strcmp(tc->name, ti->name) == 0);   
00263     /* check full type equivalence, resolving typedefs */
00264     if (!typeequiv) {
00265       /* only if tc is not a typedef (no '|' on it) */
00266       if (tc->str && ti->str && !strstr(tc->str,"|")) {
00267     typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
00268       }
00269     }
00270     if (typeequiv) {
00271       /* Already exists in the table.  Just add additional types to the list */
00272       if (ti->clientdata) tc->clientdata = ti->clientdata;
00273       head = tc;
00274       next = tc->next;
00275       goto l1;
00276     }
00277     tc = tc->prev;
00278   }
00279   head = ti;
00280   next = 0;
00281 
00282   /* Place in list */
00283   ti->prev = *tl;
00284   *tl = ti;
00285 
00286   /* Build linked lists */
00287   l1:
00288   ret = head;
00289   tc = ti + 1;
00290   /* Patch up the rest of the links */
00291   while (tc->name) {
00292     head->next = tc;
00293     tc->prev = head;
00294     head = tc;
00295     tc++;
00296   }
00297   if (next) next->prev = head;
00298   head->next = next;
00299 
00300   return ret;
00301 }

SWIGRUNTIME const char* SWIG_UnpackData const char *  c,
void *  ptr,
size_t  sz
 

Definition at line 440 of file HyperEstraier_wrap.cxx.

00440                                                      {
00441   register unsigned char *u = (unsigned char *) ptr;
00442   register const unsigned char *eu =  u + sz;
00443   for (; u != eu; ++u) {
00444     register int d = *(c++);
00445     register unsigned char uu = 0;
00446     if ((d >= '0') && (d <= '9'))
00447       uu = ((d - '0') << 4);
00448     else if ((d >= 'a') && (d <= 'f'))
00449       uu = ((d - ('a'-10)) << 4);
00450     else 
00451       return (char *) 0;
00452     d = *(c++);
00453     if ((d >= '0') && (d <= '9'))
00454       uu |= (d - '0');
00455     else if ((d >= 'a') && (d <= 'f'))
00456       uu |= (d - ('a'-10));
00457     else 
00458       return (char *) 0;
00459     *u = uu;
00460   }
00461   return c;
00462 }

SWIGRUNTIME const char* SWIG_UnpackDataName const char *  c,
void *  ptr,
size_t  sz,
const char *  name
 

Definition at line 531 of file HyperEstraier_wrap.cxx.

References SWIG_UnpackData().

00531                                                                            {
00532   if (*c != '_') {
00533     if (strcmp(c,"NULL") == 0) {
00534       memset(ptr,0,sz);
00535       return name;
00536     } else {
00537       return 0;
00538     }
00539   }
00540   return SWIG_UnpackData(++c,ptr,sz);
00541 }

SWIGRUNTIME const char* SWIG_UnpackVoidPtr const char *  c,
void **  ptr,
const char *  name
 

Definition at line 503 of file HyperEstraier_wrap.cxx.

References SWIG_UnpackData().

00503                                                                 {
00504   if (*c != '_') {
00505     if (strcmp(c,"NULL") == 0) {
00506       *ptr = (void *) 0;
00507       return name;
00508     } else {
00509       return 0;
00510     }
00511   }
00512   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00513 }

SWIGEXPORT void   ) 
 

Definition at line 3465 of file HyperEstraier_wrap.cxx.

References _wrap_Condition_add_attr(), _wrap_Condition_allocate(), _wrap_Condition_cond_get(), _wrap_Condition_cond_set(), _wrap_Condition_set_max(), _wrap_Condition_set_options(), _wrap_Condition_set_order(), _wrap_Condition_set_phrase(), _wrap_Database_allocate(), _wrap_Database_close(), _wrap_Database_doc_num(), _wrap_Database_err_msg(), _wrap_Database_error(), _wrap_Database_etch_doc(), _wrap_Database_fatal(), _wrap_Database_flush(), _wrap_Database_get_doc(), _wrap_Database_name(), _wrap_Database_open(), _wrap_Database_optimize(), _wrap_Database_out_doc(), _wrap_Database_put_doc(), _wrap_Database_search(), _wrap_Database_set_cache_size(), _wrap_Database_set_special_cache(), _wrap_Database_size(), _wrap_Database_sync(), _wrap_Database_uri_to_id(), _wrap_Database_word_num(), _wrap_Document_add_attr(), _wrap_Document_add_hidden_text(), _wrap_Document_add_text(), _wrap_Document_allocate(), _wrap_Document_attr(), _wrap_Document_attr_names(), _wrap_Document_cat_texts(), _wrap_Document_doc_get(), _wrap_Document_doc_set(), _wrap_Document_dump_draft(), _wrap_Document_id(), _wrap_Document_make_snippet(), _wrap_Document_texts(), _wrap_IntVector___getitem__(), _wrap_IntVector___len__(), _wrap_IntVector___setitem__(), _wrap_IntVector_allocate(), _wrap_IntVector_clear(), _wrap_IntVector_each(), _wrap_IntVector_emptyq___(), _wrap_IntVector_pop(), _wrap_IntVector_push(), _wrap_new_Condition(), _wrap_new_Database(), _wrap_new_Document(), _wrap_new_IntVector(), _wrap_new_StrStrMap(), _wrap_new_StrVector(), _wrap_StrStrMap___getitem__(), _wrap_StrStrMap___len__(), _wrap_StrStrMap___setitem__(), _wrap_StrStrMap_allocate(), _wrap_StrStrMap_clear(), _wrap_StrStrMap_delete(), _wrap_StrStrMap_each(), _wrap_StrStrMap_emptyq___(), _wrap_StrStrMap_has_keyq___(), _wrap_StrStrMap_keys(), _wrap_StrStrMap_values(), _wrap_StrVector___getitem__(), _wrap_StrVector___len__(), _wrap_StrVector___setitem__(), _wrap_StrVector_allocate(), _wrap_StrVector_clear(), _wrap_StrVector_each(), _wrap_StrVector_emptyq___(), _wrap_StrVector_pop(), _wrap_StrVector_push(), free_estraier_Condition(), free_estraier_Database(), free_estraier_Document(), free_std_map_Sl_std_string_Sc_std_string_Sg_(), free_std_vector_Sl_int_Sg_(), free_std_vector_Sl_std_string_Sg_(), swig_class::klass, mHyperEstraier, rb_define_alloc_func, SWIG_define_class, SWIG_InitRuntime, SWIG_TypeClientData(), SWIG_TypeRegister(), SWIGTYPE_p_estraier__Condition, SWIGTYPE_p_estraier__Database, SWIGTYPE_p_estraier__Document, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIGTYPE_p_std__vectorTint_t, SWIGTYPE_p_std__vectorTstd__string_t, and VALUEFUNC.

03465                                           {
03466     int i;
03467     
03468     SWIG_InitRuntime();
03469     mHyperEstraier = rb_define_module("HyperEstraier");
03470     
03471     for (i = 0; swig_types_initial[i]; i++) {
03472         swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
03473         SWIG_define_class(swig_types[i]);
03474     }
03475     
03476     
03477     cStrVector.klass = rb_define_class_under(mHyperEstraier, "StrVector", rb_cObject);
03478     SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, (void *) &cStrVector);
03479     rb_include_module(cStrVector.klass, rb_eval_string("Enumerable"));
03480     rb_define_alloc_func(cStrVector.klass, _wrap_StrVector_allocate);
03481     rb_define_method(cStrVector.klass, "initialize", VALUEFUNC(_wrap_new_StrVector), -1);
03482     rb_define_method(cStrVector.klass, "length", VALUEFUNC(_wrap_StrVector___len__), -1);
03483     rb_define_method(cStrVector.klass, "empty?", VALUEFUNC(_wrap_StrVector_emptyq___), -1);
03484     rb_define_method(cStrVector.klass, "clear", VALUEFUNC(_wrap_StrVector_clear), -1);
03485     rb_define_method(cStrVector.klass, "push", VALUEFUNC(_wrap_StrVector_push), -1);
03486     rb_define_method(cStrVector.klass, "pop", VALUEFUNC(_wrap_StrVector_pop), -1);
03487     rb_define_method(cStrVector.klass, "[]", VALUEFUNC(_wrap_StrVector___getitem__), -1);
03488     rb_define_method(cStrVector.klass, "[]=", VALUEFUNC(_wrap_StrVector___setitem__), -1);
03489     rb_define_method(cStrVector.klass, "each", VALUEFUNC(_wrap_StrVector_each), -1);
03490     cStrVector.mark = 0;
03491     cStrVector.destroy = (void (*)(void *)) free_std_vector_Sl_std_string_Sg_;
03492     
03493     cIntVector.klass = rb_define_class_under(mHyperEstraier, "IntVector", rb_cObject);
03494     SWIG_TypeClientData(SWIGTYPE_p_std__vectorTint_t, (void *) &cIntVector);
03495     rb_include_module(cIntVector.klass, rb_eval_string("Enumerable"));
03496     rb_define_alloc_func(cIntVector.klass, _wrap_IntVector_allocate);
03497     rb_define_method(cIntVector.klass, "initialize", VALUEFUNC(_wrap_new_IntVector), -1);
03498     rb_define_method(cIntVector.klass, "length", VALUEFUNC(_wrap_IntVector___len__), -1);
03499     rb_define_method(cIntVector.klass, "empty?", VALUEFUNC(_wrap_IntVector_emptyq___), -1);
03500     rb_define_method(cIntVector.klass, "clear", VALUEFUNC(_wrap_IntVector_clear), -1);
03501     rb_define_method(cIntVector.klass, "push", VALUEFUNC(_wrap_IntVector_push), -1);
03502     rb_define_method(cIntVector.klass, "pop", VALUEFUNC(_wrap_IntVector_pop), -1);
03503     rb_define_method(cIntVector.klass, "[]", VALUEFUNC(_wrap_IntVector___getitem__), -1);
03504     rb_define_method(cIntVector.klass, "[]=", VALUEFUNC(_wrap_IntVector___setitem__), -1);
03505     rb_define_method(cIntVector.klass, "each", VALUEFUNC(_wrap_IntVector_each), -1);
03506     cIntVector.mark = 0;
03507     cIntVector.destroy = (void (*)(void *)) free_std_vector_Sl_int_Sg_;
03508     
03509     cStrStrMap.klass = rb_define_class_under(mHyperEstraier, "StrStrMap", rb_cObject);
03510     SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, (void *) &cStrStrMap);
03511     rb_include_module(cStrStrMap.klass, rb_eval_string("Enumerable"));
03512     rb_define_alloc_func(cStrStrMap.klass, _wrap_StrStrMap_allocate);
03513     rb_define_method(cStrStrMap.klass, "initialize", VALUEFUNC(_wrap_new_StrStrMap), -1);
03514     rb_define_method(cStrStrMap.klass, "length", VALUEFUNC(_wrap_StrStrMap___len__), -1);
03515     rb_define_method(cStrStrMap.klass, "empty?", VALUEFUNC(_wrap_StrStrMap_emptyq___), -1);
03516     rb_define_method(cStrStrMap.klass, "clear", VALUEFUNC(_wrap_StrStrMap_clear), -1);
03517     rb_define_method(cStrStrMap.klass, "[]", VALUEFUNC(_wrap_StrStrMap___getitem__), -1);
03518     rb_define_method(cStrStrMap.klass, "[]=", VALUEFUNC(_wrap_StrStrMap___setitem__), -1);
03519     rb_define_method(cStrStrMap.klass, "delete", VALUEFUNC(_wrap_StrStrMap_delete), -1);
03520     rb_define_method(cStrStrMap.klass, "has_key?", VALUEFUNC(_wrap_StrStrMap_has_keyq___), -1);
03521     rb_define_method(cStrStrMap.klass, "keys", VALUEFUNC(_wrap_StrStrMap_keys), -1);
03522     rb_define_method(cStrStrMap.klass, "values", VALUEFUNC(_wrap_StrStrMap_values), -1);
03523     rb_define_method(cStrStrMap.klass, "each", VALUEFUNC(_wrap_StrStrMap_each), -1);
03524     cStrStrMap.mark = 0;
03525     cStrStrMap.destroy = (void (*)(void *)) free_std_map_Sl_std_string_Sc_std_string_Sg_;
03526     
03527     cCondition.klass = rb_define_class_under(mHyperEstraier, "Condition", rb_cObject);
03528     SWIG_TypeClientData(SWIGTYPE_p_estraier__Condition, (void *) &cCondition);
03529     rb_define_alloc_func(cCondition.klass, _wrap_Condition_allocate);
03530     rb_define_method(cCondition.klass, "initialize", VALUEFUNC(_wrap_new_Condition), -1);
03531     rb_define_const(cCondition.klass,"SURE", INT2NUM(estraier::Condition::SURE));
03532     rb_define_const(cCondition.klass,"USUAL", INT2NUM(estraier::Condition::USUAL));
03533     rb_define_const(cCondition.klass,"FAST", INT2NUM(estraier::Condition::FAST));
03534     rb_define_const(cCondition.klass,"AGITO", INT2NUM(estraier::Condition::AGITO));
03535     rb_define_const(cCondition.klass,"NOIDF", INT2NUM(estraier::Condition::NOIDF));
03536     rb_define_const(cCondition.klass,"SIMPLE", INT2NUM(estraier::Condition::SIMPLE));
03537     rb_define_method(cCondition.klass, "cond=", VALUEFUNC(_wrap_Condition_cond_set), -1);
03538     rb_define_method(cCondition.klass, "cond", VALUEFUNC(_wrap_Condition_cond_get), -1);
03539     rb_define_method(cCondition.klass, "set_phrase", VALUEFUNC(_wrap_Condition_set_phrase), -1);
03540     rb_define_method(cCondition.klass, "add_attr", VALUEFUNC(_wrap_Condition_add_attr), -1);
03541     rb_define_method(cCondition.klass, "set_order", VALUEFUNC(_wrap_Condition_set_order), -1);
03542     rb_define_method(cCondition.klass, "set_max", VALUEFUNC(_wrap_Condition_set_max), -1);
03543     rb_define_method(cCondition.klass, "set_options", VALUEFUNC(_wrap_Condition_set_options), -1);
03544     cCondition.mark = 0;
03545     cCondition.destroy = (void (*)(void *)) free_estraier_Condition;
03546     
03547     cDocument.klass = rb_define_class_under(mHyperEstraier, "Document", rb_cObject);
03548     SWIG_TypeClientData(SWIGTYPE_p_estraier__Document, (void *) &cDocument);
03549     rb_define_alloc_func(cDocument.klass, _wrap_Document_allocate);
03550     rb_define_method(cDocument.klass, "initialize", VALUEFUNC(_wrap_new_Document), -1);
03551     rb_define_method(cDocument.klass, "doc=", VALUEFUNC(_wrap_Document_doc_set), -1);
03552     rb_define_method(cDocument.klass, "doc", VALUEFUNC(_wrap_Document_doc_get), -1);
03553     rb_define_method(cDocument.klass, "add_attr", VALUEFUNC(_wrap_Document_add_attr), -1);
03554     rb_define_method(cDocument.klass, "add_text", VALUEFUNC(_wrap_Document_add_text), -1);
03555     rb_define_method(cDocument.klass, "add_hidden_text", VALUEFUNC(_wrap_Document_add_hidden_text), -1);
03556     rb_define_method(cDocument.klass, "id", VALUEFUNC(_wrap_Document_id), -1);
03557     rb_define_method(cDocument.klass, "attr_names", VALUEFUNC(_wrap_Document_attr_names), -1);
03558     rb_define_method(cDocument.klass, "attr", VALUEFUNC(_wrap_Document_attr), -1);
03559     rb_define_method(cDocument.klass, "cat_texts", VALUEFUNC(_wrap_Document_cat_texts), -1);
03560     rb_define_method(cDocument.klass, "texts", VALUEFUNC(_wrap_Document_texts), -1);
03561     rb_define_method(cDocument.klass, "dump_draft", VALUEFUNC(_wrap_Document_dump_draft), -1);
03562     rb_define_method(cDocument.klass, "make_snippet", VALUEFUNC(_wrap_Document_make_snippet), -1);
03563     cDocument.mark = 0;
03564     cDocument.destroy = (void (*)(void *)) free_estraier_Document;
03565     
03566     cDatabase.klass = rb_define_class_under(mHyperEstraier, "Database", rb_cObject);
03567     SWIG_TypeClientData(SWIGTYPE_p_estraier__Database, (void *) &cDatabase);
03568     rb_define_alloc_func(cDatabase.klass, _wrap_Database_allocate);
03569     rb_define_method(cDatabase.klass, "initialize", VALUEFUNC(_wrap_new_Database), -1);
03570     rb_define_const(cDatabase.klass,"ERRNOERR", INT2NUM(estraier::Database::ERRNOERR));
03571     rb_define_const(cDatabase.klass,"ERRINVAL", INT2NUM(estraier::Database::ERRINVAL));
03572     rb_define_const(cDatabase.klass,"ERRACCES", INT2NUM(estraier::Database::ERRACCES));
03573     rb_define_const(cDatabase.klass,"ERRLOCK", INT2NUM(estraier::Database::ERRLOCK));
03574     rb_define_const(cDatabase.klass,"ERRDB", INT2NUM(estraier::Database::ERRDB));
03575     rb_define_const(cDatabase.klass,"ERRIO", INT2NUM(estraier::Database::ERRIO));
03576     rb_define_const(cDatabase.klass,"ERRNOITEM", INT2NUM(estraier::Database::ERRNOITEM));
03577     rb_define_const(cDatabase.klass,"ERRMISC", INT2NUM(estraier::Database::ERRMISC));
03578     rb_define_const(cDatabase.klass,"DBREADER", INT2NUM(estraier::Database::DBREADER));
03579     rb_define_const(cDatabase.klass,"DBWRITER", INT2NUM(estraier::Database::DBWRITER));
03580     rb_define_const(cDatabase.klass,"DBCREAT", INT2NUM(estraier::Database::DBCREAT));
03581     rb_define_const(cDatabase.klass,"DBTRUNC", INT2NUM(estraier::Database::DBTRUNC));
03582     rb_define_const(cDatabase.klass,"DBNOLCK", INT2NUM(estraier::Database::DBNOLCK));
03583     rb_define_const(cDatabase.klass,"DBLCKNB", INT2NUM(estraier::Database::DBLCKNB));
03584     rb_define_const(cDatabase.klass,"DBPERFNG", INT2NUM(estraier::Database::DBPERFNG));
03585     rb_define_const(cDatabase.klass,"PDCLEAN", INT2NUM(estraier::Database::PDCLEAN));
03586     rb_define_const(cDatabase.klass,"ODCLEAN", INT2NUM(estraier::Database::ODCLEAN));
03587     rb_define_const(cDatabase.klass,"OPTNOPURGE", INT2NUM(estraier::Database::OPTNOPURGE));
03588     rb_define_const(cDatabase.klass,"OPTNODBOPT", INT2NUM(estraier::Database::OPTNODBOPT));
03589     rb_define_const(cDatabase.klass,"GDNOATTR", INT2NUM(estraier::Database::GDNOATTR));
03590     rb_define_const(cDatabase.klass,"GDNOTEXT", INT2NUM(estraier::Database::GDNOTEXT));
03591     rb_define_method(cDatabase.klass, "open", VALUEFUNC(_wrap_Database_open), -1);
03592     rb_define_method(cDatabase.klass, "close", VALUEFUNC(_wrap_Database_close), -1);
03593     rb_define_method(cDatabase.klass, "put_doc", VALUEFUNC(_wrap_Database_put_doc), -1);
03594     rb_define_method(cDatabase.klass, "search", VALUEFUNC(_wrap_Database_search), -1);
03595     rb_define_singleton_method(cDatabase.klass, "err_msg", VALUEFUNC(_wrap_Database_err_msg), -1);
03596     rb_define_method(cDatabase.klass, "error", VALUEFUNC(_wrap_Database_error), -1);
03597     rb_define_method(cDatabase.klass, "fatal", VALUEFUNC(_wrap_Database_fatal), -1);
03598     rb_define_method(cDatabase.klass, "flush", VALUEFUNC(_wrap_Database_flush), -1);
03599     rb_define_method(cDatabase.klass, "sync", VALUEFUNC(_wrap_Database_sync), -1);
03600     rb_define_method(cDatabase.klass, "optimize", VALUEFUNC(_wrap_Database_optimize), -1);
03601     rb_define_method(cDatabase.klass, "out_doc", VALUEFUNC(_wrap_Database_out_doc), -1);
03602     rb_define_method(cDatabase.klass, "get_doc", VALUEFUNC(_wrap_Database_get_doc), -1);
03603     rb_define_method(cDatabase.klass, "uri_to_id", VALUEFUNC(_wrap_Database_uri_to_id), -1);
03604     rb_define_method(cDatabase.klass, "etch_doc", VALUEFUNC(_wrap_Database_etch_doc), -1);
03605     rb_define_method(cDatabase.klass, "name", VALUEFUNC(_wrap_Database_name), -1);
03606     rb_define_method(cDatabase.klass, "doc_num", VALUEFUNC(_wrap_Database_doc_num), -1);
03607     rb_define_method(cDatabase.klass, "word_num", VALUEFUNC(_wrap_Database_word_num), -1);
03608     rb_define_method(cDatabase.klass, "size", VALUEFUNC(_wrap_Database_size), -1);
03609     rb_define_method(cDatabase.klass, "set_cache_size", VALUEFUNC(_wrap_Database_set_cache_size), -1);
03610     rb_define_method(cDatabase.klass, "set_special_cache", VALUEFUNC(_wrap_Database_set_special_cache), -1);
03611     cDatabase.mark = 0;
03612     cDatabase.destroy = (void (*)(void *)) free_estraier_Database;
03613 }


Variable Documentation

VALUE _cSWIG_Pointer = Qnil [static]
 

Definition at line 650 of file HyperEstraier_wrap.cxx.

VALUE _mSWIG = Qnil [static]
 

Definition at line 649 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_ESTCOND[] = {{"_p_ESTCOND", 0, "ESTCOND *", 0, 0, 0, 0},{"_p_ESTCOND", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3436 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_ESTDOC[] = {{"_p_ESTDOC", 0, "ESTDOC *", 0, 0, 0, 0},{"_p_ESTDOC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3439 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_estraier__Condition[] = {{"_p_estraier__Condition", 0, "estraier::Condition *", 0, 0, 0, 0},{"_p_estraier__Condition", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3435 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_estraier__Database[] = {{"_p_estraier__Database", 0, "estraier::Database *", 0, 0, 0, 0},{"_p_estraier__Database", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3437 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_estraier__Document[] = {{"_p_estraier__Document", 0, "estraier::Document *", 0, 0, 0, 0},{"_p_estraier__Document", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3443 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0, 0, 0, 0},{"_p_std__mapTstd__string_std__string_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3441 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_std__vectorTint_t[] = {{"_p_std__vectorTint_t", 0, "std::vector<int > *", 0, 0, 0, 0},{"_p_std__vectorTint_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3442 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0, 0, 0, 0},{"_p_std__vectorTstd__string_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3440 of file HyperEstraier_wrap.cxx.

swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|VALUE *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 3438 of file HyperEstraier_wrap.cxx.

swig_class cCondition
 

Definition at line 1090 of file HyperEstraier_wrap.cxx.

swig_class cDatabase
 

Definition at line 1096 of file HyperEstraier_wrap.cxx.

swig_class cDocument
 

Definition at line 1093 of file HyperEstraier_wrap.cxx.

swig_class cIntVector
 

Definition at line 1029 of file HyperEstraier_wrap.cxx.

swig_class cStrStrMap
 

Definition at line 1084 of file HyperEstraier_wrap.cxx.

swig_class cStrVector
 

Definition at line 999 of file HyperEstraier_wrap.cxx.

VALUE mHyperEstraier [static]
 

Definition at line 861 of file HyperEstraier_wrap.cxx.

Referenced by SWIGEXPORT().

VALUE swig_runtime_data_type_pointer = Qnil [static]
 

Definition at line 651 of file HyperEstraier_wrap.cxx.

swig_type_info* swig_type_list = 0 [static]
 

Definition at line 583 of file HyperEstraier_wrap.cxx.

swig_type_info** swig_type_list_handle = &swig_type_list [static]
 

Definition at line 584 of file HyperEstraier_wrap.cxx.

swig_type_info* swig_types[10] [static]
 

Definition at line 854 of file HyperEstraier_wrap.cxx.

swig_type_info* swig_types_initial[] [static]
 

Initial value:

Definition at line 3445 of file HyperEstraier_wrap.cxx.


Generated on Thu Sep 8 02:02:21 2005 for HyperEstraierWrapper by  doxygen 1.4.4