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

HyperEstraier_wrap.cpp File Reference

#include <string.h>
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include <stdlib.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_type_info
struct  swig_command_info
struct  swig_constant_info
struct  swig_variable_info

Defines

#define SWIG_TEMPLATE_DISAMBIGUATOR
#define SWIG_RUNTIME_VERSION   "1"
#define SWIG_TYPE_TABLE_NAME
#define SWIGINLINE
#define SWIGRUNTIME   static
#define SWIGRUNTIMEINLINE   SWIGRUNTIME SWIGINLINE
#define SWIGEXPORT(a)   a
#define SWIGPERL
#define SWIGPERL5
#define SWIG_CALLXS(_name)   _name(cv)
#define SWIG_contract_assert(expr, msg)   if (!(expr)) { SWIG_croak(msg); } else
#define MAGIC_PPERL
#define SWIGCLASS_STATIC   static
#define SWIG_MAGIC(a, b)   (SV *a, MAGIC *b)
#define PL_sv_yes   sv_yes
#define PL_sv_undef   sv_undef
#define PL_na   na
#define SWIG_OWNER   1
#define SWIG_SHADOW   2
#define SWIG_ConvertPtr(obj, pp, type, flags)   SWIG_Perl_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags)   SWIG_Perl_NewPointerObj(p, type, flags)
#define SWIG_MakePackedObj(sv, p, s, type)   SWIG_Perl_MakePackedObj(sv, p, s, type )
#define SWIG_ConvertPacked(obj, p, s, type, flags)   SWIG_Perl_ConvertPacked(obj, p, s, type, flags)
#define SWIG_MakePtr(sv, ptr, type, flags)   SWIG_Perl_MakePtr(sv, ptr, type, flags)
#define SWIG_SetError(str)   SWIG_Perl_SetError(str)
#define SWIG_SetErrorSV(str)   SWIG_Perl_SetErrorSV(str)
#define SWIG_SetErrorf   SWIG_Perl_SetErrorf
#define SWIG_MAYBE_PERL_OBJECT
#define SWIG_Runtime_GetTypeList   SWIG_Perl_GetTypeList
#define SWIG_fail   goto fail
#define SWIG_croak(x)   { SWIG_SetError(x); goto fail; }
#define SWIG_croakSV(x)   { SWIG_SetErrorSV(x); goto fail; }
#define SWIG_INT   1
#define SWIG_FLOAT   2
#define SWIG_STRING   3
#define SWIG_POINTER   4
#define SWIG_BINARY   5
#define swig_create_magic(s, a, b, c)   _swig_create_magic(s,a,b,c)
#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_ESTDOC   swig_types[3]
#define SWIGTYPE_p_std__vectorTstd__string_t   swig_types[4]
#define SWIGTYPE_p_std__mapTstd__string_std__string_t   swig_types[5]
#define SWIGTYPE_p_std__vectorTint_t   swig_types[6]
#define SWIGTYPE_p_std__string   swig_types[7]
#define SWIGTYPE_p_estraier__Document   swig_types[8]
#define SWIGTYPE_p_size_t   swig_types[9]
#define SWIG_init   boot_HyperEstraier
#define SWIG_name   "HyperEstraierc::boot_HyperEstraier"
#define SWIG_prefix   "HyperEstraierc::"
#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_croak(b)
#define MAGIC_CLASS

Typedefs

typedef void *(* swig_converter_func )(void *)
typedef swig_type_info *(* swig_dycast_func )(void **)
typedef swig_type_info swig_type_info
typedef int(* SwigMagicFunc )(SV *, MAGIC *)
typedef int(* SwigMagicFuncHack )(SV *, MAGIC *)
typedef SwigPerlWrapper * SwigPerlWrapperPtr
typedef swig_constant_info swig_constant_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 swig_type_info ** SWIG_Perl_GetTypeListHandle ()
SWIGRUNTIMEINLINE swig_type_infoSWIG_Perl_GetTypeList ()
static swig_type_infoSWIG_Perl_TypeCheckRV (SWIG_MAYBE_PERL_OBJECT SV *rv, swig_type_info *ty)
static int SWIG_Perl_ConvertPtr (SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags)
static void SWIG_Perl_MakePtr (SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags)
static SWIGINLINE SV * SWIG_Perl_NewPointerObj (SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags)
static void SWIG_Perl_MakePackedObj (SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type)
static int SWIG_Perl_ConvertPacked (SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty, int flags)
static SWIGINLINE void SWIG_Perl_SetError (SWIG_MAYBE_PERL_OBJECT const char *error)
static SWIGINLINE void SWIG_Perl_SetErrorSV (SWIG_MAYBE_PERL_OBJECT SV *error)
static void SWIG_Perl_SetErrorf (const char *fmt,...)
typedef XS (SwigPerlWrapper)
static void _swig_create_magic (SV *sv, char *name, int(*set)(SV *, MAGIC *), int(*get)(SV *, MAGIC *))
 SWIGEXPORT (void) SWIG_init(CV *cv)
double SwigSvToNumber (SV *sv)
std::string SwigSvToString (SV *sv)
void SwigSvFromString (SV *sv, 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__get (std::vector< std::string > *self, int i)
static void std_vector_Sl_std_string_Sg__set (std::vector< std::string > *self, int i, std::string x)
static int std_vector_Sl_int_Sg__pop (std::vector< int > *self)
static int std_vector_Sl_int_Sg__get (std::vector< int > *self, int i)
static void std_vector_Sl_int_Sg__set (std::vector< int > *self, int i, int x)
static std::string & std_map_Sl_std_string_Sc_std_string_Sg__get (std::map< std::string, std::string > *self, std::string const &key)
static void std_map_Sl_std_string_Sc_std_string_Sg__set (std::map< std::string, std::string > *self, std::string const &key, std::string const &x)
static void std_map_Sl_std_string_Sc_std_string_Sg__del (std::map< std::string, std::string > *self, std::string const &key)
static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key (std::map< std::string, std::string > *self, std::string const &key)
SWIGCLASS_STATIC int swig_magic_readonly (pTHX_ SV *sv, MAGIC *mg)
 XS (_wrap_new_StrVector__SWIG_0)
 XS (_wrap_new_StrVector__SWIG_1)
 XS (_wrap_new_StrVector__SWIG_2)
 XS (_wrap_new_StrVector__SWIG_3)
 XS (_wrap_new_StrVector)
 XS (_wrap_StrVector_size)
 XS (_wrap_StrVector_empty)
 XS (_wrap_StrVector_clear)
 XS (_wrap_StrVector_push)
 XS (_wrap_StrVector_pop)
 XS (_wrap_StrVector_get)
 XS (_wrap_StrVector_set)
 XS (_wrap_delete_StrVector)
 XS (_wrap_new_IntVector__SWIG_0)
 XS (_wrap_new_IntVector__SWIG_1)
 XS (_wrap_new_IntVector__SWIG_2)
 XS (_wrap_new_IntVector__SWIG_3)
 XS (_wrap_new_IntVector)
 XS (_wrap_IntVector_size)
 XS (_wrap_IntVector_empty)
 XS (_wrap_IntVector_clear)
 XS (_wrap_IntVector_push)
 XS (_wrap_IntVector_pop)
 XS (_wrap_IntVector_get)
 XS (_wrap_IntVector_set)
 XS (_wrap_delete_IntVector)
 XS (_wrap_new_StrStrMap__SWIG_0)
 XS (_wrap_new_StrStrMap__SWIG_1)
 XS (_wrap_new_StrStrMap)
 XS (_wrap_StrStrMap_size)
 XS (_wrap_StrStrMap_empty)
 XS (_wrap_StrStrMap_clear)
 XS (_wrap_StrStrMap_get)
 XS (_wrap_StrStrMap_set)
 XS (_wrap_StrStrMap_del)
 XS (_wrap_StrStrMap_has_key)
 XS (_wrap_delete_StrStrMap)
 XS (_wrap_Condition_cond_set)
 XS (_wrap_Condition_cond_get)
 XS (_wrap_new_Condition)
 XS (_wrap_delete_Condition)
 XS (_wrap_Condition_set_phrase)
 XS (_wrap_Condition_add_attr)
 XS (_wrap_Condition_set_order)
 XS (_wrap_Condition_set_max)
 XS (_wrap_Condition_set_options)
 XS (_wrap_Document_doc_set)
 XS (_wrap_Document_doc_get)
 XS (_wrap_new_Document__SWIG_0)
 XS (_wrap_new_Document__SWIG_1)
 XS (_wrap_new_Document__SWIG_2)
 XS (_wrap_new_Document)
 XS (_wrap_delete_Document)
 XS (_wrap_Document_add_attr)
 XS (_wrap_Document_add_text)
 XS (_wrap_Document_add_hidden_text)
 XS (_wrap_Document_id)
 XS (_wrap_Document_attr_names)
 XS (_wrap_Document_attr)
 XS (_wrap_Document_cat_texts)
 XS (_wrap_Document_texts)
 XS (_wrap_Document_dump_draft)
 XS (_wrap_Document_make_snippet)
 XS (_wrap_new_Database)
 XS (_wrap_delete_Database)
 XS (_wrap_Database_open)
 XS (_wrap_Database_close)
 XS (_wrap_Database_put_doc)
 XS (_wrap_Database_search)
 XS (_wrap_Database_err_msg)
 XS (_wrap_Database_error)
 XS (_wrap_Database_fatal)
 XS (_wrap_Database_flush)
 XS (_wrap_Database_sync)
 XS (_wrap_Database_optimize)
 XS (_wrap_Database_out_doc)
 XS (_wrap_Database_get_doc)
 XS (_wrap_Database_uri_to_id)
 XS (_wrap_Database_etch_doc)
 XS (_wrap_Database_iter_init)
 XS (_wrap_Database_iter_next)
 XS (_wrap_Database_name)
 XS (_wrap_Database_doc_num)
 XS (_wrap_Database_word_num)
 XS (_wrap_Database_size)
 XS (_wrap_Database_set_cache_size)
 XS (_wrap_Database_set_special_cache)
static void SWIG_Perl_SetTypeListHandle (swig_type_info **handle)
static swig_type_info ** SWIG_Perl_LookupTypePointer (swig_type_info **type_list_handle)
 XS (SWIG_init)

Variables

static swig_type_infoswig_type_list = 0
static swig_type_info ** swig_type_list_handle = &swig_type_list
static swig_type_infoswig_types [11]
static swig_type_info _swigt__p_estraier__Condition [] = {{"HyperEstraier::Condition", 0, "estraier::Condition *", 0, 0, 0, 0},{"HyperEstraier::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 [] = {{"HyperEstraier::Database", 0, "estraier::Database *", 0, 0, 0, 0},{"HyperEstraier::Database", 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 [] = {{"HyperEstraier::StrVector", 0, "std::vector<std::string > *", 0, 0, 0, 0},{"HyperEstraier::StrVector", 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 [] = {{"HyperEstraier::StrStrMap", 0, "std::map<std::string,std::string > *", 0, 0, 0, 0},{"HyperEstraier::StrStrMap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_std__vectorTint_t [] = {{"HyperEstraier::IntVector", 0, "std::vector<int > *", 0, 0, 0, 0},{"HyperEstraier::IntVector", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_std__string [] = {{"_p_std__string", 0, "std::string *", 0, 0, 0, 0},{"_p_std__string", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_estraier__Document [] = {{"HyperEstraier::Document", 0, "estraier::Document *", 0, 0, 0, 0},{"HyperEstraier::Document", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_info _swigt__p_size_t [] = {{"_p_size_t", 0, "size_t *", 0, 0, 0, 0},{"_p_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}
static swig_type_infoswig_types_initial []
static swig_constant_info swig_constants []
static swig_variable_info swig_variables []
static swig_command_info swig_commands []


Define Documentation

#define MAGIC_CLASS
 

Definition at line 1156 of file HyperEstraier_wrap.cpp.

#define MAGIC_PPERL
 

Definition at line 568 of file HyperEstraier_wrap.cpp.

Referenced by swig_magic_readonly().

#define PL_na   na
 

Definition at line 611 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_ConvertPacked(), and XS().

#define PL_sv_undef   sv_undef
 

Definition at line 608 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define PL_sv_yes   sv_yes
 

Definition at line 605 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_BINARY   5
 

Definition at line 894 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_CALLXS _name   )     _name(cv)
 

Definition at line 541 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_contract_assert expr,
msg   )     if (!(expr)) { SWIG_croak(msg); } else
 

Definition at line 549 of file HyperEstraier_wrap.cpp.

#define SWIG_ConvertPacked obj,
p,
s,
type,
flags   )     SWIG_Perl_ConvertPacked(obj, p, s, type, flags)
 

Definition at line 643 of file HyperEstraier_wrap.cpp.

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

Definition at line 637 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Condition_add_attr(), _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_close(), _wrap_Database_doc_num(), _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_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_clear(), _wrap_IntVector_each(), _wrap_IntVector_emptyq___(), _wrap_IntVector_pop(), _wrap_IntVector_push(), _wrap_new_Document(), _wrap_new_Document__SWIG_2(), _wrap_new_IntVector(), _wrap_new_IntVector__SWIG_3(), _wrap_new_StrStrMap(), _wrap_new_StrStrMap__SWIG_1(), _wrap_new_StrVector(), _wrap_new_StrVector__SWIG_3(), _wrap_StrStrMap___getitem__(), _wrap_StrStrMap___len__(), _wrap_StrStrMap___setitem__(), _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_clear(), _wrap_StrVector_each(), _wrap_StrVector_emptyq___(), _wrap_StrVector_pop(), _wrap_StrVector_push(), SWIG_Ruby_MustGetPtr(), and XS().

#define swig_create_magic s,
a,
b,
 )     _swig_create_magic(s,a,b,c)
 

Definition at line 920 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_croak  )     { SWIG_SetError(x); goto fail; }
 

Definition at line 873 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_croakSV  )     { SWIG_SetErrorSV(x); goto fail; }
 

Definition at line 874 of file HyperEstraier_wrap.cpp.

#define SWIG_DivisionByZero   6
 

Definition at line 1042 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_exception a,
 )     SWIG_croak(b)
 

Definition at line 1050 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Condition_add_attr(), _wrap_Condition_set_max(), _wrap_Condition_set_options(), _wrap_Condition_set_order(), _wrap_Condition_set_phrase(), _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_attr(), _wrap_Document_attr_names(), _wrap_Document_cat_texts(), _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_clear(), _wrap_IntVector_each(), _wrap_IntVector_emptyq___(), _wrap_IntVector_pop(), _wrap_IntVector_push(), _wrap_new_Condition(), _wrap_new_Database(), _wrap_new_Document__SWIG_0(), _wrap_new_Document__SWIG_1(), _wrap_new_Document__SWIG_2(), _wrap_new_IntVector__SWIG_0(), _wrap_new_IntVector__SWIG_1(), _wrap_new_IntVector__SWIG_2(), _wrap_new_IntVector__SWIG_3(), _wrap_new_StrStrMap__SWIG_0(), _wrap_new_StrStrMap__SWIG_1(), _wrap_new_StrVector__SWIG_0(), _wrap_new_StrVector__SWIG_1(), _wrap_new_StrVector__SWIG_2(), _wrap_new_StrVector__SWIG_3(), _wrap_StrStrMap___getitem__(), _wrap_StrStrMap___len__(), _wrap_StrStrMap___setitem__(), _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_clear(), _wrap_StrVector_each(), _wrap_StrVector_emptyq___(), _wrap_StrVector_pop(), _wrap_StrVector_push(), and XS().

#define SWIG_fail   goto fail
 

Definition at line 872 of file HyperEstraier_wrap.cpp.

#define SWIG_FLOAT   2
 

Definition at line 891 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_IndexError   4
 

Definition at line 1040 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_IntVector___getitem__(), _wrap_IntVector___setitem__(), _wrap_IntVector_pop(), _wrap_StrStrMap___getitem__(), _wrap_StrStrMap_delete(), _wrap_StrVector___getitem__(), _wrap_StrVector___setitem__(), _wrap_StrVector_pop(), SWIG_exception_(), and XS().

#define SWIG_init   boot_HyperEstraier
 

Definition at line 1018 of file HyperEstraier_wrap.cpp.

#define SWIG_INT   1
 

Definition at line 890 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_IOError   2
 

Definition at line 1038 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_MAGIC a,
 )     (SV *a, MAGIC *b)
 

Definition at line 571 of file HyperEstraier_wrap.cpp.

#define SWIG_MakePackedObj sv,
p,
s,
type   )     SWIG_Perl_MakePackedObj(sv, p, s, type )
 

Definition at line 641 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_MakePtr sv,
ptr,
type,
flags   )     SWIG_Perl_MakePtr(sv, ptr, type, flags)
 

Definition at line 654 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_NewPointerObj(), and XS().

#define SWIG_MAYBE_PERL_OBJECT
 

Definition at line 668 of file HyperEstraier_wrap.cpp.

#define SWIG_MemoryError   1
 

Definition at line 1037 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_name   "HyperEstraierc::boot_HyperEstraier"
 

Definition at line 1020 of file HyperEstraier_wrap.cpp.

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

Definition at line 639 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Condition_cond_get(), _wrap_Database_etch_doc(), _wrap_Database_get_doc(), _wrap_Database_search(), _wrap_Document_attr_names(), _wrap_Document_doc_get(), and _wrap_Document_texts().

#define SWIG_OverflowError   7
 

Definition at line 1043 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_OWNER   1
 

Definition at line 621 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_MakePtr(), and XS().

#define SWIG_POINTER   4
 

Definition at line 893 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_prefix   "HyperEstraierc::"
 

Definition at line 1021 of file HyperEstraier_wrap.cpp.

#define SWIG_Runtime_GetTypeList   SWIG_Perl_GetTypeList
 

Definition at line 696 of file HyperEstraier_wrap.cpp.

#define SWIG_RUNTIME_VERSION   "1"
 

Definition at line 47 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_GetTypeListHandle(), SWIG_Perl_SetTypeListHandle(), and SWIG_Ruby_InitRuntime().

#define SWIG_RuntimeError   3
 

Definition at line 1039 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Condition_add_attr(), _wrap_Condition_set_max(), _wrap_Condition_set_options(), _wrap_Condition_set_order(), _wrap_Condition_set_phrase(), _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_attr(), _wrap_Document_attr_names(), _wrap_Document_cat_texts(), _wrap_Document_dump_draft(), _wrap_Document_id(), _wrap_Document_make_snippet(), _wrap_Document_texts(), _wrap_IntVector___len__(), _wrap_IntVector_clear(), _wrap_IntVector_each(), _wrap_IntVector_emptyq___(), _wrap_IntVector_push(), _wrap_new_Condition(), _wrap_new_Database(), _wrap_new_Document__SWIG_0(), _wrap_new_Document__SWIG_1(), _wrap_new_Document__SWIG_2(), _wrap_new_IntVector__SWIG_0(), _wrap_new_IntVector__SWIG_1(), _wrap_new_IntVector__SWIG_2(), _wrap_new_IntVector__SWIG_3(), _wrap_new_StrStrMap__SWIG_0(), _wrap_new_StrStrMap__SWIG_1(), _wrap_new_StrVector__SWIG_0(), _wrap_new_StrVector__SWIG_1(), _wrap_new_StrVector__SWIG_2(), _wrap_new_StrVector__SWIG_3(), _wrap_StrStrMap___len__(), _wrap_StrStrMap___setitem__(), _wrap_StrStrMap_clear(), _wrap_StrStrMap_each(), _wrap_StrStrMap_emptyq___(), _wrap_StrStrMap_has_keyq___(), _wrap_StrStrMap_keys(), _wrap_StrStrMap_values(), _wrap_StrVector___len__(), _wrap_StrVector_clear(), _wrap_StrVector_each(), _wrap_StrVector_emptyq___(), _wrap_StrVector_push(), SWIG_exception_(), and XS().

#define SWIG_SetError str   )     SWIG_Perl_SetError(str)
 

Definition at line 656 of file HyperEstraier_wrap.cpp.

#define SWIG_SetErrorf   SWIG_Perl_SetErrorf
 

Definition at line 662 of file HyperEstraier_wrap.cpp.

#define SWIG_SetErrorSV str   )     SWIG_Perl_SetErrorSV(str)
 

Definition at line 658 of file HyperEstraier_wrap.cpp.

#define SWIG_SHADOW   2
 

Definition at line 622 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_MakePtr(), and XS().

#define SWIG_STRING   3
 

Definition at line 892 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIG_SyntaxError   8
 

Definition at line 1044 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_SystemError   10
 

Definition at line 1046 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_TEMPLATE_DISAMBIGUATOR
 

Definition at line 33 of file HyperEstraier_wrap.cpp.

#define SWIG_TYPE_TABLE_NAME
 

Definition at line 55 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_GetTypeListHandle(), SWIG_Perl_SetTypeListHandle(), and SWIG_Ruby_InitRuntime().

#define SWIG_TypeError   5
 

Definition at line 1041 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_new_StrVector__SWIG_2(), _wrap_StrStrMap___getitem__(), _wrap_StrStrMap___setitem__(), _wrap_StrStrMap_delete(), _wrap_StrStrMap_has_keyq___(), _wrap_StrVector___setitem__(), _wrap_StrVector_push(), and SWIG_exception_().

#define SWIG_UnknownError   99
 

Definition at line 1047 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIG_ValueError   9
 

Definition at line 1045 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_exception_().

#define SWIGCLASS_STATIC   static
 

Definition at line 569 of file HyperEstraier_wrap.cpp.

#define SWIGEXPORT  )     a
 

Definition at line 454 of file HyperEstraier_wrap.cpp.

#define SWIGINLINE
 

Definition at line 64 of file HyperEstraier_wrap.cpp.

#define SWIGPERL
 

Definition at line 510 of file HyperEstraier_wrap.cpp.

#define SWIGPERL5
 

Definition at line 511 of file HyperEstraier_wrap.cpp.

#define SWIGRUNTIME   static
 

Definition at line 77 of file HyperEstraier_wrap.cpp.

#define SWIGRUNTIMEINLINE   SWIGRUNTIME SWIGINLINE
 

Definition at line 80 of file HyperEstraier_wrap.cpp.

#define SWIGTYPE_p_ESTCOND   swig_types[1]
 

Definition at line 1005 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Condition_cond_get(), _wrap_Condition_cond_set(), and XS().

#define SWIGTYPE_p_ESTDOC   swig_types[3]
 

Definition at line 1007 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Document_doc_get(), _wrap_Document_doc_set(), _wrap_new_Document(), _wrap_new_Document__SWIG_2(), and XS().

#define SWIGTYPE_p_estraier__Condition   swig_types[0]
 

Definition at line 1004 of file HyperEstraier_wrap.cpp.

Referenced by _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_search(), SWIGEXPORT(), and XS().

#define SWIGTYPE_p_estraier__Database   swig_types[2]
 

Definition at line 1006 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Database_allocate(), _wrap_Database_close(), _wrap_Database_doc_num(), _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(), SWIGEXPORT(), and XS().

#define SWIGTYPE_p_estraier__Document   swig_types[8]
 

Definition at line 1012 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Database_etch_doc(), _wrap_Database_get_doc(), _wrap_Database_put_doc(), _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(), SWIGEXPORT(), and XS().

#define SWIGTYPE_p_size_t   swig_types[9]
 

Definition at line 1013 of file HyperEstraier_wrap.cpp.

#define SWIGTYPE_p_std__mapTstd__string_std__string_t   swig_types[5]
 

Definition at line 1009 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Database_etch_doc(), _wrap_new_StrStrMap(), _wrap_new_StrStrMap__SWIG_1(), _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(), SWIGEXPORT(), and XS().

#define SWIGTYPE_p_std__string   swig_types[7]
 

Definition at line 1011 of file HyperEstraier_wrap.cpp.

Referenced by XS().

#define SWIGTYPE_p_std__vectorTint_t   swig_types[6]
 

Definition at line 1010 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Database_search(), _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_IntVector(), _wrap_new_IntVector__SWIG_3(), SWIGEXPORT(), and XS().

#define SWIGTYPE_p_std__vectorTstd__string_t   swig_types[4]
 

Definition at line 1008 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_Document_attr_names(), _wrap_Document_make_snippet(), _wrap_Document_texts(), _wrap_new_StrVector(), _wrap_new_StrVector__SWIG_3(), _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(), SWIGEXPORT(), and XS().


Typedef Documentation

typedef struct swig_constant_info swig_constant_info
 

typedef void*(* swig_converter_func)(void *)
 

Definition at line 87 of file HyperEstraier_wrap.cpp.

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

Definition at line 88 of file HyperEstraier_wrap.cpp.

typedef struct swig_type_info swig_type_info
 

typedef int(* SwigMagicFunc)(SV *, MAGIC *)
 

Definition at line 572 of file HyperEstraier_wrap.cpp.

typedef int(* SwigMagicFuncHack)(SV *, MAGIC *)
 

Definition at line 577 of file HyperEstraier_wrap.cpp.

typedef SwigPerlWrapper* SwigPerlWrapperPtr
 

Definition at line 880 of file HyperEstraier_wrap.cpp.


Function Documentation

static void _swig_create_magic SV *  sv,
char *  name,
int(*)(SV *, MAGIC *)  set,
int(*)(SV *, MAGIC *)  get
[static]
 

Definition at line 922 of file HyperEstraier_wrap.cpp.

00922                                                                                                              {
00923   #else
00924      static void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) {
00925   #endif
00926 #else
00927 #  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
00928 static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
00929 #endif
00930   MAGIC *mg;
00931   sv_magic(sv,sv,'U',(char *) name,strlen(name));
00932   mg = mg_find(sv,'U');
00933   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
00934   mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
00935   mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
00936   mg->mg_virtual->svt_len = 0;
00937   mg->mg_virtual->svt_clear = 0;
00938   mg->mg_virtual->svt_free = 0;
00939 }

static void std_map_Sl_std_string_Sc_std_string_Sg__del std::map< std::string, std::string > *  self,
std::string const &  key
[static]
 

Definition at line 1137 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01137                                                                                                                 {
01138                 std::map<std::string,std::string >::iterator i = self->find(key);
01139                 if (i != self->end())
01140                     self->erase(i);
01141                 else
01142                     throw std::out_of_range("key not found");
01143             }

static std::string& std_map_Sl_std_string_Sc_std_string_Sg__get std::map< std::string, std::string > *  self,
std::string const &  key
[static]
 

Definition at line 1127 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01127                                                                                                                       {
01128                 std::map<std::string,std::string >::iterator i = self->find(key);
01129                 if (i != self->end())
01130                     return i->second;
01131                 else
01132                     throw std::out_of_range("key not found");
01133             }

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

Definition at line 1144 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_StrStrMap_has_keyq___(), and XS().

01144                                                                                                                     {
01145                 std::map<std::string,std::string >::iterator i = self->find(key);
01146                 return i != self->end();
01147             }

static void std_map_Sl_std_string_Sc_std_string_Sg__set std::map< std::string, std::string > *  self,
std::string const &  key,
std::string const &  x
[static]
 

Definition at line 1134 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01134                                                                                                                                    {
01135                 (*self)[key] = x;
01136             }

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

Definition at line 1113 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01113                                                                  {
01114                 int size = int(self->size());
01115                 if (i>=0 && i<size)
01116                     return (*self)[i];
01117                 else
01118                     throw std::out_of_range("vector index out of range");
01119             }

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

Definition at line 1106 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_IntVector_pop(), and XS().

01106                                                            {
01107                 if (self->size() == 0)
01108                     throw std::out_of_range("pop from empty vector");
01109                 int x = self->back();
01110                 self->pop_back();
01111                 return x;
01112             }

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

Definition at line 1120 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01120                                                                         {
01121                 int size = int(self->size());
01122                 if (i>=0 && i<size)
01123                     (*self)[i] = x;
01124                 else
01125                     throw std::out_of_range("vector index out of range");
01126             }

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

Definition at line 1092 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01092                                                                                     {
01093                 int size = int(self->size());
01094                 if (i>=0 && i<size)
01095                     return (*self)[i];
01096                 else
01097                     throw std::out_of_range("vector index out of range");
01098             }

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

Definition at line 1085 of file HyperEstraier_wrap.cpp.

Referenced by _wrap_StrVector_pop(), and XS().

01085                                                                               {
01086                 if (self->size() == 0)
01087                     throw std::out_of_range("pop from empty vector");
01088                 std::string x = self->back();
01089                 self->pop_back();
01090                 return x;
01091             }

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

Definition at line 1099 of file HyperEstraier_wrap.cpp.

Referenced by XS().

01099                                                                                            {
01100                 int size = int(self->size());
01101                 if (i>=0 && i<size)
01102                     (*self)[i] = x;
01103                 else
01104                     throw std::out_of_range("vector index out of range");
01105             }

SWIGCLASS_STATIC int swig_magic_readonly pTHX_ SV *  sv,
MAGIC *  mg
 

Definition at line 1158 of file HyperEstraier_wrap.cpp.

References MAGIC_PPERL.

01158                                                                   {
01159     MAGIC_PPERL
01160     sv = sv; mg = mg;
01161     croak("Value is read-only.");
01162     return 0;
01163 }

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

Definition at line 307 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_PackDataName(), SWIG_PackVoidPtr(), SWIG_Perl_MakePackedObj(), and SWIG_Ruby_NewPackedObj().

00307                                              {
00308   static char hex[17] = "0123456789abcdef";
00309   unsigned char *u = (unsigned char *) ptr;
00310   const unsigned char *eu =  u + sz;
00311   register unsigned char uu;
00312   for (; u != eu; ++u) {
00313     uu = *u;
00314     *(c++) = hex[(uu & 0xf0) >> 4];
00315     *(c++) = hex[uu & 0xf];
00316   }
00317   return c;
00318 }

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

Definition at line 400 of file HyperEstraier_wrap.cpp.

References SWIG_PackData().

00400                                                                                   {
00401   char *r = buff;
00402   size_t lname = (name ? strlen(name) : 0);
00403   if ((2*sz + 2 + lname) > bsz) return 0;
00404   *(r++) = '_';
00405   r = SWIG_PackData(r,ptr,sz);
00406   if (lname) {
00407     strncpy(r,name,lname+1);
00408   } else {
00409     *r = 0;
00410   }
00411   return buff;
00412 }

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

Definition at line 376 of file HyperEstraier_wrap.cpp.

References SWIG_PackData().

00376                                                                       {
00377   char *r = buff;
00378   if ((2*sizeof(void *) + 2) > bsz) return 0;
00379   *(r++) = '_';
00380   r = SWIG_PackData(r,&ptr,sizeof(void *));
00381   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00382   strcpy(r,name);
00383   return buff;
00384 }

static int SWIG_Perl_ConvertPacked SWIG_MAYBE_PERL_OBJECT SV *  obj,
void *  ptr,
int  sz,
swig_type_info ty,
int  flags
[static]
 

Definition at line 836 of file HyperEstraier_wrap.cpp.

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

00836                                                                                                           {
00837   swig_type_info *tc;
00838   const char  *c = 0;
00839 
00840   if ((!obj) || (!SvOK(obj))) return -1;
00841   c = SvPV(obj, PL_na);
00842   /* Pointer values must start with leading underscore */
00843   if (*c != '_') return -1;
00844   c++;
00845   c = SWIG_UnpackData(c,ptr,sz);
00846   if (ty) {
00847     tc = SWIG_TypeCheck(c,ty);
00848     if (!tc) return -1;
00849   }
00850   return 0;
00851 }

static int SWIG_Perl_ConvertPtr SWIG_MAYBE_PERL_OBJECT SV *  sv,
void **  ptr,
swig_type_info _t,
int  flags
[static]
 

Definition at line 726 of file HyperEstraier_wrap.cpp.

References SWIG_TypeCast(), and SWIG_TypeCheck().

00726                                                                                                {
00727   swig_type_info *tc;
00728   void *voidptr = (void *)0;
00729 
00730   /* If magical, apply more magic */
00731   if (SvGMAGICAL(sv))
00732     mg_get(sv);
00733 
00734   /* Check to see if this is an object */
00735   if (sv_isobject(sv)) {
00736     SV *tsv = (SV*) SvRV(sv);
00737     IV tmp = 0;
00738     if ((SvTYPE(tsv) == SVt_PVHV)) {
00739       MAGIC *mg;
00740       if (SvMAGICAL(tsv)) {
00741         mg = mg_find(tsv,'P');
00742         if (mg) {
00743           sv = mg->mg_obj;
00744           if (sv_isobject(sv)) {
00745             tmp = SvIV((SV*)SvRV(sv));
00746           }
00747         }
00748       } else {
00749         return -1;
00750       }
00751     } else {
00752       tmp = SvIV((SV*)SvRV(sv));
00753     }
00754     voidptr = (void *)tmp;
00755     if (!_t) {
00756       *(ptr) = voidptr;
00757       return 0;
00758     }
00759   } else if (! SvOK(sv)) {            /* Check for undef */
00760     *(ptr) = (void *) 0;
00761     return 0;
00762   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
00763     *(ptr) = (void *) 0;
00764     if (!SvROK(sv))
00765       return 0;
00766     else
00767       return -1;
00768   } else {                            /* Don't know what it is */
00769     *(ptr) = (void *) 0;
00770     return -1;
00771   }
00772   if (_t) {
00773     /* Now see if the types match */
00774     char *_c = HvNAME(SvSTASH(SvRV(sv)));
00775     tc = SWIG_TypeCheck(_c,_t);
00776     if (!tc) {
00777       *ptr = voidptr;
00778       return -1;
00779     }
00780     *ptr = SWIG_TypeCast(tc,voidptr);
00781     return 0;
00782   }
00783   *ptr = voidptr;
00784   return 0;
00785 }

SWIGRUNTIMEINLINE swig_type_info* SWIG_Perl_GetTypeList  ) 
 

Definition at line 691 of file HyperEstraier_wrap.cpp.

References SWIG_Perl_GetTypeListHandle().

00691                         {
00692   swig_type_info **tlh = SWIG_Perl_GetTypeListHandle();
00693   return tlh ? *tlh : (swig_type_info*)0;
00694 }

static swig_type_info** SWIG_Perl_GetTypeListHandle  )  [static]
 

Definition at line 672 of file HyperEstraier_wrap.cpp.

References SWIG_RUNTIME_VERSION, and SWIG_TYPE_TABLE_NAME.

Referenced by SWIG_Perl_GetTypeList(), and SWIG_Perl_LookupTypePointer().

00672                               {
00673   static void *type_pointer = (void *)0;
00674   SV *pointer;
00675 
00676   /* first check if pointer already created */
00677   if (!type_pointer) {
00678     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
00679     if (pointer && SvOK(pointer)) {
00680       type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
00681     }
00682   }
00683 
00684   return (swig_type_info **) type_pointer;
00685 }

static swig_type_info** SWIG_Perl_LookupTypePointer swig_type_info **  type_list_handle  )  [static]
 

Definition at line 4551 of file HyperEstraier_wrap.cpp.

References SWIG_Perl_GetTypeListHandle(), and SWIG_Perl_SetTypeListHandle().

Referenced by XS().

04551                                                                {
04552     swig_type_info **type_pointer;
04553     
04554     /* first check if module already created */
04555     type_pointer = SWIG_Perl_GetTypeListHandle();
04556     if (type_pointer) {
04557         return type_pointer;
04558     } else {
04559         /* create a new module and variable */
04560         SWIG_Perl_SetTypeListHandle(type_list_handle);
04561         return type_list_handle;
04562     }
04563 }

static void SWIG_Perl_MakePackedObj SWIG_MAYBE_PERL_OBJECT SV *  sv,
void *  ptr,
int  sz,
swig_type_info type
[static]
 

Definition at line 824 of file HyperEstraier_wrap.cpp.

References swig_type_info::name, and SWIG_PackData().

00824                                                                                                   {
00825   char result[1024];
00826   char *r = result;
00827   if ((2*sz + 1 + strlen(type->name)) > 1000) return;
00828   *(r++) = '_';
00829   r = SWIG_PackData(r,ptr,sz);
00830   strcpy(r,type->name);
00831   sv_setpv(sv, result);
00832 }

static void SWIG_Perl_MakePtr SWIG_MAYBE_PERL_OBJECT SV *  sv,
void *  ptr,
swig_type_info t,
int  flags
[static]
 

Definition at line 788 of file HyperEstraier_wrap.cpp.

References swig_type_info::name, SWIG_OWNER, and SWIG_SHADOW.

00788                                                                                           {
00789   if (ptr && (flags & SWIG_SHADOW)) {
00790     SV *self;
00791     SV *obj=newSV(0);
00792     HV *hash=newHV();
00793     HV *stash;
00794     sv_setref_pv(obj, (char *) t->name, ptr);
00795     stash=SvSTASH(SvRV(obj));
00796     if (flags & SWIG_OWNER) {
00797       HV *hv;
00798       GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
00799       if (!isGV(gv))
00800         gv_init(gv, stash, "OWNER", 5, FALSE);
00801       hv=GvHVn(gv);
00802       hv_store_ent(hv, obj, newSViv(1), 0);
00803     }
00804     sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
00805     SvREFCNT_dec(obj);
00806     self=newRV_noinc((SV *)hash);
00807     sv_setsv(sv, self);
00808     SvREFCNT_dec((SV *)self);
00809     sv_bless(sv, stash);
00810   }
00811   else {
00812     sv_setref_pv(sv, (char *) t->name, ptr);
00813   }
00814 }

static SWIGINLINE SV* SWIG_Perl_NewPointerObj SWIG_MAYBE_PERL_OBJECT void *  ptr,
swig_type_info t,
int  flags
[static]
 

Definition at line 817 of file HyperEstraier_wrap.cpp.

References SWIG_MakePtr.

00817                                                                                         {
00818   SV *result = sv_newmortal();
00819   SWIG_MakePtr(result, ptr, t, flags);
00820   return result;
00821 }

static SWIGINLINE void SWIG_Perl_SetError SWIG_MAYBE_PERL_OBJECT const char *  error  )  [static]
 

Definition at line 854 of file HyperEstraier_wrap.cpp.

00854                                                              {
00855   if (error) sv_setpv(perl_get_sv("@", TRUE), error);
00856 }

static void SWIG_Perl_SetErrorf const char *  fmt,
  ...
[static]
 

Definition at line 864 of file HyperEstraier_wrap.cpp.

00864                                           {
00865   va_list args;
00866   va_start(args, fmt);
00867   sv_vsetpvfn(perl_get_sv("@", TRUE), fmt, strlen(fmt), &args, Null(SV**), 0, Null(bool*));
00868   va_end(args);
00869 }

static SWIGINLINE void SWIG_Perl_SetErrorSV SWIG_MAYBE_PERL_OBJECT SV *  error  )  [static]
 

Definition at line 859 of file HyperEstraier_wrap.cpp.

00859                                                        {
00860   if (error) sv_setsv(perl_get_sv("@", TRUE), error);
00861 }

static void SWIG_Perl_SetTypeListHandle swig_type_info **  handle  )  [static]
 

Definition at line 4542 of file HyperEstraier_wrap.cpp.

References SWIG_RUNTIME_VERSION, swig_type_list_handle, and SWIG_TYPE_TABLE_NAME.

Referenced by SWIG_Perl_LookupTypePointer().

04542                                                                  {
04543     SV *pointer;
04544     
04545     /* create a new pointer */
04546     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
04547     sv_setiv(pointer, PTR2IV(swig_type_list_handle));
04548 }

static swig_type_info* SWIG_Perl_TypeCheckRV SWIG_MAYBE_PERL_OBJECT SV *  rv,
swig_type_info ty
[static]
 

Definition at line 699 of file HyperEstraier_wrap.cpp.

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

00699                                                                          {
00700   swig_type_info *s;
00701   if (!ty) return 0;        /* Void pointer */
00702   s = ty->next;             /* First element always just a name */
00703   do {
00704     if (sv_derived_from(rv, (char *) s->name)) {
00705       if (s == ty->next) return s;
00706       /* Move s to the top of the linked list */
00707       s->prev->next = s->next;
00708       if (s->next) {
00709         s->next->prev = s->prev;
00710       }
00711       /* Insert s as second element in the list */
00712       s->next = ty->next;
00713       if (ty->next) ty->next->prev = s;
00714       ty->next = s;
00715       s->prev = ty;
00716       return s;
00717     }
00718     s = s->next;
00719   } while (s && (s != ty->next));
00720   return 0;
00721 }

static void SWIG_PropagateClientData swig_type_info type  )  [static]
 

Definition at line 495 of file HyperEstraier_wrap.cpp.

References SWIG_PropagateClientDataTL().

00495                                                {
00496   SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
00497 }

SWIGRUNTIME void SWIG_PropagateClientDataTL swig_type_info tl,
swig_type_info type
 

Definition at line 355 of file HyperEstraier_wrap.cpp.

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

Referenced by SWIG_PropagateClientData().

00355                                                                      {
00356   swig_type_info *equiv = type->next;
00357   swig_type_info *tc;
00358   if (!type->clientdata) return;
00359   while (equiv) {
00360     if (!equiv->converter) {
00361       tc = tl;
00362       while (tc) {
00363         if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
00364           SWIG_TypeClientDataTL(tl,tc, type->clientdata);
00365         tc = tc->prev;
00366       }
00367     }
00368     equiv = equiv->next;
00369   }
00370 }

SWIGRUNTIMEINLINE void* SWIG_TypeCast swig_type_info ty,
void *  ptr
 

Definition at line 219 of file HyperEstraier_wrap.cpp.

References swig_type_info::converter.

Referenced by SWIG_Perl_ConvertPtr(), and SWIG_Ruby_ConvertPtr().

00219                                              {
00220   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
00221 }

SWIGRUNTIME swig_type_info* SWIG_TypeCheck const char *  c,
swig_type_info ty
 

Definition at line 191 of file HyperEstraier_wrap.cpp.

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

Referenced by SWIG_Perl_ConvertPacked(), SWIG_Perl_ConvertPtr(), SWIG_Ruby_CheckConvert(), SWIG_Ruby_ConvertPacked(), and SWIG_Ruby_ConvertPtr().

00191                                                   {
00192   swig_type_info *s;
00193   if (!ty) return 0;        /* Void pointer */
00194   s = ty->next;             /* First element always just a name */
00195   do {
00196     if (strcmp(s->name,c) == 0) {
00197       if (s == ty->next) return s;
00198       /* Move s to the top of the linked list */
00199       s->prev->next = s->next;
00200       if (s->next) {
00201         s->next->prev = s->prev;
00202       }
00203       /* Insert s as second element in the list */
00204       s->next = ty->next;
00205       if (ty->next) ty->next->prev = s;
00206       ty->next = s;
00207       s->prev = ty;
00208       return s;
00209     }
00210     s = s->next;
00211   } while (s && (s != ty->next));
00212   return 0;
00213 }

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

Definition at line 485 of file HyperEstraier_wrap.cpp.

References SWIG_TypeClientDataTL().

Referenced by SWIGEXPORT(), and XS().

00485                                                           {
00486   SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
00487 }

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

Definition at line 284 of file HyperEstraier_wrap.cpp.

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

Referenced by SWIG_PropagateClientDataTL(), SWIG_TypeClientData(), and SWIG_TypeClientDataTL().

00284                                                                                 {
00285   swig_type_info *tc, *equiv;
00286   if (ti->clientdata) return;
00287   /* if (ti->clientdata == clientdata) return; */
00288   ti->clientdata = clientdata;
00289   equiv = ti->next;
00290   while (equiv) {
00291     if (!equiv->converter) {
00292       tc = tl;
00293       while (tc) {
00294         if ((strcmp(tc->name, equiv->name) == 0))
00295           SWIG_TypeClientDataTL(tl,tc,clientdata);
00296         tc = tc->prev;
00297       }
00298     }
00299     equiv = equiv->next;
00300   }
00301 }

SWIGRUNTIME swig_type_info* SWIG_TypeDynamicCast swig_type_info ty,
void **  ptr
 

Definition at line 227 of file HyperEstraier_wrap.cpp.

References swig_type_info::dcast.

00227                                                      {
00228   swig_type_info *lastty = ty;
00229   if (!ty || !ty->dcast) return ty;
00230   while (ty && (ty->dcast)) {
00231     ty = (*ty->dcast)(ptr);
00232     if (ty) lastty = ty;
00233   }
00234   return lastty;
00235 }

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

Definition at line 122 of file HyperEstraier_wrap.cpp.

References SWIG_TypeNameComp().

Referenced by SWIG_TypeQueryTL(), and SWIG_TypeRegisterTL().

00122                                                {
00123   int equiv = 0;
00124   const char* te = tb + strlen(tb);
00125   const char* ne = nb;
00126   while (!equiv && *ne) {
00127     for (nb = ne; *ne; ++ne) {
00128       if (*ne == '|') break;
00129     }
00130     equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
00131     if (*ne) ++ne;
00132   }
00133   return equiv;
00134 }

SWIGRUNTIMEINLINE const char* SWIG_TypeName const swig_type_info ty  ) 
 

Definition at line 241 of file HyperEstraier_wrap.cpp.

References swig_type_info::name.

00241                                         {
00242   return ty->name;
00243 }

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

Definition at line 108 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_TypeEquiv().

00109                                           {
00110   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00111     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00112     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00113     if (*f1 != *f2) return *f1 - *f2;
00114   }
00115   return (l1 - f1) - (l2 - f2);
00116 }

SWIGRUNTIME const char* SWIG_TypePrettyName const swig_type_info type  ) 
 

Definition at line 250 of file HyperEstraier_wrap.cpp.

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

00250                                                 {
00251   /* The "str" field contains the equivalent pretty names of the
00252      type, separated by vertical-bar characters.  We choose
00253      to print the last name, as it is often (?) the most
00254      specific. */
00255   if (type->str != NULL) {
00256     const char *last_name = type->str;
00257     const char *s;
00258     for (s = type->str; *s; s++)
00259       if (*s == '|') last_name = s+1;
00260     return last_name;
00261   }
00262   else
00263     return type->name;
00264 }

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

Definition at line 479 of file HyperEstraier_wrap.cpp.

References SWIG_TypeQueryTL().

00479                                  {
00480   return SWIG_TypeQueryTL(*swig_type_list_handle, name);
00481 }

SWIGRUNTIME swig_type_info* SWIG_TypeQueryTL swig_type_info tl,
const char *  name
 

Definition at line 270 of file HyperEstraier_wrap.cpp.

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

Referenced by SWIG_TypeQuery().

00270                                                        {
00271   swig_type_info *ty = tl;
00272   while (ty) {
00273     if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
00274     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
00275     ty = ty->prev;
00276   }
00277   return 0;
00278 }

static swig_type_info* SWIG_TypeRegister swig_type_info ti  )  [static]
 

Definition at line 473 of file HyperEstraier_wrap.cpp.

References SWIG_TypeRegisterTL().

Referenced by SWIGEXPORT(), and XS().

00473                                       {
00474   return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
00475 }

SWIGRUNTIME swig_type_info* SWIG_TypeRegisterTL swig_type_info **  tl,
swig_type_info ti
 

Definition at line 140 of file HyperEstraier_wrap.cpp.

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

Referenced by SWIG_TypeRegister().

00140                                                              {
00141   swig_type_info *tc, *head, *ret, *next;
00142   /* Check to see if this type has already been registered */
00143   tc = *tl;
00144   while (tc) {
00145     /* check simple type equivalence */
00146     int typeequiv = (strcmp(tc->name, ti->name) == 0);   
00147     /* check full type equivalence, resolving typedefs */
00148     if (!typeequiv) {
00149       /* only if tc is not a typedef (no '|' on it) */
00150       if (tc->str && ti->str && !strstr(tc->str,"|")) {
00151     typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
00152       }
00153     }
00154     if (typeequiv) {
00155       /* Already exists in the table.  Just add additional types to the list */
00156       if (ti->clientdata) tc->clientdata = ti->clientdata;
00157       head = tc;
00158       next = tc->next;
00159       goto l1;
00160     }
00161     tc = tc->prev;
00162   }
00163   head = ti;
00164   next = 0;
00165 
00166   /* Place in list */
00167   ti->prev = *tl;
00168   *tl = ti;
00169 
00170   /* Build linked lists */
00171   l1:
00172   ret = head;
00173   tc = ti + 1;
00174   /* Patch up the rest of the links */
00175   while (tc->name) {
00176     head->next = tc;
00177     tc->prev = head;
00178     head = tc;
00179     tc++;
00180   }
00181   if (next) next->prev = head;
00182   head->next = next;
00183 
00184   return ret;
00185 }

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

Definition at line 324 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_ConvertPacked(), SWIG_Ruby_ConvertPacked(), SWIG_UnpackDataName(), and SWIG_UnpackVoidPtr().

00324                                                      {
00325   register unsigned char *u = (unsigned char *) ptr;
00326   register const unsigned char *eu =  u + sz;
00327   for (; u != eu; ++u) {
00328     register int d = *(c++);
00329     register unsigned char uu = 0;
00330     if ((d >= '0') && (d <= '9'))
00331       uu = ((d - '0') << 4);
00332     else if ((d >= 'a') && (d <= 'f'))
00333       uu = ((d - ('a'-10)) << 4);
00334     else 
00335       return (char *) 0;
00336     d = *(c++);
00337     if ((d >= '0') && (d <= '9'))
00338       uu |= (d - '0');
00339     else if ((d >= 'a') && (d <= 'f'))
00340       uu |= (d - ('a'-10));
00341     else 
00342       return (char *) 0;
00343     *u = uu;
00344   }
00345   return c;
00346 }

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

Definition at line 415 of file HyperEstraier_wrap.cpp.

References SWIG_UnpackData().

00415                                                                            {
00416   if (*c != '_') {
00417     if (strcmp(c,"NULL") == 0) {
00418       memset(ptr,0,sz);
00419       return name;
00420     } else {
00421       return 0;
00422     }
00423   }
00424   return SWIG_UnpackData(++c,ptr,sz);
00425 }

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

Definition at line 387 of file HyperEstraier_wrap.cpp.

References SWIG_UnpackData().

00387                                                                 {
00388   if (*c != '_') {
00389     if (strcmp(c,"NULL") == 0) {
00390       *ptr = (void *) 0;
00391       return name;
00392     } else {
00393       return 0;
00394     }
00395   }
00396   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00397 }

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 }

void SwigSvFromString SV *  sv,
const std::string &  s
 

Definition at line 1065 of file HyperEstraier_wrap.cpp.

01065                                                   {
01066     sv_setpv(sv,s.c_str());
01067 }

double SwigSvToNumber SV *  sv  ) 
 

Definition at line 1058 of file HyperEstraier_wrap.cpp.

01058                               {
01059     return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
01060 }

std::string SwigSvToString SV *  sv  ) 
 

Definition at line 1061 of file HyperEstraier_wrap.cpp.

01061                                  {
01062     STRLEN len;
01063     return SvPV(sv,len);
01064 }

XS SWIG_init   ) 
 

Definition at line 4570 of file HyperEstraier_wrap.cpp.

References PL_sv_yes, SWIG_BINARY, swig_constants, swig_create_magic, SWIG_FLOAT, SWIG_INT, SWIG_MakePackedObj, SWIG_MakePtr, SWIG_Perl_LookupTypePointer(), SWIG_POINTER, SWIG_STRING, swig_type_list_handle, SWIG_TypeClientData(), SWIG_TypeRegister(), swig_types_initial, 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 swig_constant_info::type.

04570               {
04571     dXSARGS;
04572     int i;
04573     static int _init = 0;
04574     if (!_init) {
04575         swig_type_list_handle = SWIG_Perl_LookupTypePointer(swig_type_list_handle);
04576         for (i = 0; swig_types_initial[i]; i++) {
04577             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
04578         }   
04579         _init = 1;
04580     }
04581     
04582     /* Install commands */
04583     for (i = 0; swig_commands[i].name; i++) {
04584         newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
04585     }
04586     
04587     /* Install variables */
04588     for (i = 0; swig_variables[i].name; i++) {
04589         SV *sv;
04590         sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
04591         if (swig_variables[i].type) {
04592             SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
04593         } else {
04594             sv_setiv(sv,(IV) 0);
04595         }
04596         swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get); 
04597     }
04598     
04599     /* Install constant */
04600     for (i = 0; swig_constants[i].type; i++) {
04601         SV *sv;
04602         sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
04603         switch(swig_constants[i].type) {
04604             case SWIG_INT:
04605             sv_setiv(sv, (IV) swig_constants[i].lvalue);
04606             break;
04607             case SWIG_FLOAT:
04608             sv_setnv(sv, (double) swig_constants[i].dvalue);
04609             break;
04610             case SWIG_STRING:
04611             sv_setpv(sv, (char *) swig_constants[i].pvalue);
04612             break;
04613             case SWIG_POINTER:
04614             SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
04615             break;
04616             case SWIG_BINARY:
04617             SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
04618             break;
04619             default:
04620             break;
04621         }
04622         SvREADONLY_on(sv);
04623     }
04624     
04625     SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, (void*) "HyperEstraier::StrVector");
04626     SWIG_TypeClientData(SWIGTYPE_p_std__vectorTint_t, (void*) "HyperEstraier::IntVector");
04627     SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, (void*) "HyperEstraier::StrStrMap");
04628     SWIG_TypeClientData(SWIGTYPE_p_estraier__Condition, (void*) "HyperEstraier::Condition");
04629     SWIG_TypeClientData(SWIGTYPE_p_estraier__Document, (void*) "HyperEstraier::Document");
04630     SWIG_TypeClientData(SWIGTYPE_p_estraier__Database, (void*) "HyperEstraier::Database");
04631     ST(0) = &PL_sv_yes;
04632     XSRETURN(1);
04633 }

XS _wrap_Database_set_special_cache   ) 
 

Definition at line 4360 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

04360                                      {
04361     {
04362         estraier::Database *arg1 = (estraier::Database *) 0 ;
04363         char *arg2 = (char *) 0 ;
04364         int arg3 ;
04365         int argvi = 0;
04366         dXSARGS;
04367         
04368         if ((items < 3) || (items > 3)) {
04369             SWIG_croak("Usage: Database_set_special_cache(self,name,num);");
04370         }
04371         {
04372             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04373                 SWIG_croak("Type error in argument 1 of Database_set_special_cache. Expected _p_estraier__Database");
04374             }
04375         }
04376         if (!SvOK((SV*) ST(1))) arg2 = 0;
04377         else arg2 = (char *) SvPV(ST(1), PL_na);
04378         arg3 = (int) SvIV(ST(2));
04379         {
04380             try {
04381                 (arg1)->set_special_cache((char const *)arg2,arg3);
04382                 
04383             } catch (const char *msg) {
04384                 SWIG_exception(SWIG_RuntimeError, msg);
04385             }
04386         }
04387         
04388         XSRETURN(argvi);
04389         fail:
04390         ;
04391     }
04392     croak(Nullch);
04393 }

XS _wrap_Database_set_cache_size   ) 
 

Definition at line 4323 of file HyperEstraier_wrap.cpp.

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

04323                                   {
04324     {
04325         estraier::Database *arg1 = (estraier::Database *) 0 ;
04326         size_t arg2 ;
04327         int arg3 ;
04328         int arg4 ;
04329         int argvi = 0;
04330         dXSARGS;
04331         
04332         if ((items < 4) || (items > 4)) {
04333             SWIG_croak("Usage: Database_set_cache_size(self,size,anum,tnum);");
04334         }
04335         {
04336             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04337                 SWIG_croak("Type error in argument 1 of Database_set_cache_size. Expected _p_estraier__Database");
04338             }
04339         }
04340         arg2 = (size_t) SvUV(ST(1));
04341         arg3 = (int) SvIV(ST(2));
04342         arg4 = (int) SvIV(ST(3));
04343         {
04344             try {
04345                 (arg1)->set_cache_size(arg2,arg3,arg4);
04346                 
04347             } catch (const char *msg) {
04348                 SWIG_exception(SWIG_RuntimeError, msg);
04349             }
04350         }
04351         
04352         XSRETURN(argvi);
04353         fail:
04354         ;
04355     }
04356     croak(Nullch);
04357 }

XS _wrap_Database_size   ) 
 

Definition at line 4290 of file HyperEstraier_wrap.cpp.

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

04290                         {
04291     {
04292         estraier::Database *arg1 = (estraier::Database *) 0 ;
04293         double result;
04294         int argvi = 0;
04295         dXSARGS;
04296         
04297         if ((items < 1) || (items > 1)) {
04298             SWIG_croak("Usage: Database_size(self);");
04299         }
04300         {
04301             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04302                 SWIG_croak("Type error in argument 1 of Database_size. Expected _p_estraier__Database");
04303             }
04304         }
04305         {
04306             try {
04307                 result = (double)(arg1)->size();
04308                 
04309             } catch (const char *msg) {
04310                 SWIG_exception(SWIG_RuntimeError, msg);
04311             }
04312         }
04313         ST(argvi) = sv_newmortal();
04314         sv_setnv(ST(argvi++), (double) result);
04315         XSRETURN(argvi);
04316         fail:
04317         ;
04318     }
04319     croak(Nullch);
04320 }

XS _wrap_Database_word_num   ) 
 

Definition at line 4257 of file HyperEstraier_wrap.cpp.

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

04257                             {
04258     {
04259         estraier::Database *arg1 = (estraier::Database *) 0 ;
04260         int result;
04261         int argvi = 0;
04262         dXSARGS;
04263         
04264         if ((items < 1) || (items > 1)) {
04265             SWIG_croak("Usage: Database_word_num(self);");
04266         }
04267         {
04268             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04269                 SWIG_croak("Type error in argument 1 of Database_word_num. Expected _p_estraier__Database");
04270             }
04271         }
04272         {
04273             try {
04274                 result = (int)(arg1)->word_num();
04275                 
04276             } catch (const char *msg) {
04277                 SWIG_exception(SWIG_RuntimeError, msg);
04278             }
04279         }
04280         ST(argvi) = sv_newmortal();
04281         sv_setiv(ST(argvi++), (IV) result);
04282         XSRETURN(argvi);
04283         fail:
04284         ;
04285     }
04286     croak(Nullch);
04287 }

XS _wrap_Database_doc_num   ) 
 

Definition at line 4224 of file HyperEstraier_wrap.cpp.

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

04224                            {
04225     {
04226         estraier::Database *arg1 = (estraier::Database *) 0 ;
04227         int result;
04228         int argvi = 0;
04229         dXSARGS;
04230         
04231         if ((items < 1) || (items > 1)) {
04232             SWIG_croak("Usage: Database_doc_num(self);");
04233         }
04234         {
04235             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04236                 SWIG_croak("Type error in argument 1 of Database_doc_num. Expected _p_estraier__Database");
04237             }
04238         }
04239         {
04240             try {
04241                 result = (int)(arg1)->doc_num();
04242                 
04243             } catch (const char *msg) {
04244                 SWIG_exception(SWIG_RuntimeError, msg);
04245             }
04246         }
04247         ST(argvi) = sv_newmortal();
04248         sv_setiv(ST(argvi++), (IV) result);
04249         XSRETURN(argvi);
04250         fail:
04251         ;
04252     }
04253     croak(Nullch);
04254 }

XS _wrap_Database_name   ) 
 

Definition at line 4187 of file HyperEstraier_wrap.cpp.

References PL_sv_undef, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

04187                         {
04188     {
04189         estraier::Database *arg1 = (estraier::Database *) 0 ;
04190         char *result;
04191         int argvi = 0;
04192         dXSARGS;
04193         
04194         if ((items < 1) || (items > 1)) {
04195             SWIG_croak("Usage: Database_name(self);");
04196         }
04197         {
04198             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04199                 SWIG_croak("Type error in argument 1 of Database_name. Expected _p_estraier__Database");
04200             }
04201         }
04202         {
04203             try {
04204                 result = (char *)(arg1)->name();
04205                 
04206             } catch (const char *msg) {
04207                 SWIG_exception(SWIG_RuntimeError, msg);
04208             }
04209         }
04210         ST(argvi) = sv_newmortal();
04211         if (result) {
04212             sv_setpv((SV*)ST(argvi++), (char *) result);
04213         } else {
04214             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
04215         }
04216         XSRETURN(argvi);
04217         fail:
04218         ;
04219     }
04220     croak(Nullch);
04221 }

XS _wrap_Database_iter_next   ) 
 

Definition at line 4154 of file HyperEstraier_wrap.cpp.

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

04154                              {
04155     {
04156         estraier::Database *arg1 = (estraier::Database *) 0 ;
04157         int result;
04158         int argvi = 0;
04159         dXSARGS;
04160         
04161         if ((items < 1) || (items > 1)) {
04162             SWIG_croak("Usage: Database_iter_next(self);");
04163         }
04164         {
04165             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04166                 SWIG_croak("Type error in argument 1 of Database_iter_next. Expected _p_estraier__Database");
04167             }
04168         }
04169         {
04170             try {
04171                 result = (int)(arg1)->iter_next();
04172                 
04173             } catch (const char *msg) {
04174                 SWIG_exception(SWIG_RuntimeError, msg);
04175             }
04176         }
04177         ST(argvi) = sv_newmortal();
04178         sv_setiv(ST(argvi++), (IV) result);
04179         XSRETURN(argvi);
04180         fail:
04181         ;
04182     }
04183     croak(Nullch);
04184 }

XS _wrap_Database_iter_init   ) 
 

Definition at line 4121 of file HyperEstraier_wrap.cpp.

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

04121                              {
04122     {
04123         estraier::Database *arg1 = (estraier::Database *) 0 ;
04124         bool result;
04125         int argvi = 0;
04126         dXSARGS;
04127         
04128         if ((items < 1) || (items > 1)) {
04129             SWIG_croak("Usage: Database_iter_init(self);");
04130         }
04131         {
04132             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04133                 SWIG_croak("Type error in argument 1 of Database_iter_init. Expected _p_estraier__Database");
04134             }
04135         }
04136         {
04137             try {
04138                 result = (bool)(arg1)->iter_init();
04139                 
04140             } catch (const char *msg) {
04141                 SWIG_exception(SWIG_RuntimeError, msg);
04142             }
04143         }
04144         ST(argvi) = sv_newmortal();
04145         sv_setiv(ST(argvi++), (IV) result);
04146         XSRETURN(argvi);
04147         fail:
04148         ;
04149     }
04150     croak(Nullch);
04151 }

XS _wrap_Database_etch_doc   ) 
 

Definition at line 4080 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, SWIGTYPE_p_estraier__Database, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

04080                             {
04081     {
04082         estraier::Database *arg1 = (estraier::Database *) 0 ;
04083         estraier::Document *arg2 = (estraier::Document *) 0 ;
04084         int arg3 ;
04085         std::map<std::string,std::string > *result;
04086         int argvi = 0;
04087         dXSARGS;
04088         
04089         if ((items < 3) || (items > 3)) {
04090             SWIG_croak("Usage: Database_etch_doc(self,doc,max);");
04091         }
04092         {
04093             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04094                 SWIG_croak("Type error in argument 1 of Database_etch_doc. Expected _p_estraier__Database");
04095             }
04096         }
04097         {
04098             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_estraier__Document,0) < 0) {
04099                 SWIG_croak("Type error in argument 2 of Database_etch_doc. Expected _p_estraier__Document");
04100             }
04101         }
04102         arg3 = (int) SvIV(ST(2));
04103         {
04104             try {
04105                 result = (std::map<std::string,std::string > *)(arg1)->etch_doc(arg2,arg3);
04106                 
04107             } catch (const char *msg) {
04108                 SWIG_exception(SWIG_RuntimeError, msg);
04109             }
04110         }
04111         ST(argvi) = sv_newmortal();
04112         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|0);
04113         XSRETURN(argvi);
04114         fail:
04115         ;
04116     }
04117     croak(Nullch);
04118 }

XS _wrap_Database_uri_to_id   ) 
 

Definition at line 4044 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

04044                              {
04045     {
04046         estraier::Database *arg1 = (estraier::Database *) 0 ;
04047         char *arg2 = (char *) 0 ;
04048         int result;
04049         int argvi = 0;
04050         dXSARGS;
04051         
04052         if ((items < 2) || (items > 2)) {
04053             SWIG_croak("Usage: Database_uri_to_id(self,uri);");
04054         }
04055         {
04056             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04057                 SWIG_croak("Type error in argument 1 of Database_uri_to_id. Expected _p_estraier__Database");
04058             }
04059         }
04060         if (!SvOK((SV*) ST(1))) arg2 = 0;
04061         else arg2 = (char *) SvPV(ST(1), PL_na);
04062         {
04063             try {
04064                 result = (int)(arg1)->uri_to_id((char const *)arg2);
04065                 
04066             } catch (const char *msg) {
04067                 SWIG_exception(SWIG_RuntimeError, msg);
04068             }
04069         }
04070         ST(argvi) = sv_newmortal();
04071         sv_setiv(ST(argvi++), (IV) result);
04072         XSRETURN(argvi);
04073         fail:
04074         ;
04075     }
04076     croak(Nullch);
04077 }

XS _wrap_Database_get_doc   ) 
 

Definition at line 4007 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, SWIGTYPE_p_estraier__Database, and SWIGTYPE_p_estraier__Document.

04007                            {
04008     {
04009         estraier::Database *arg1 = (estraier::Database *) 0 ;
04010         int arg2 ;
04011         int arg3 ;
04012         estraier::Document *result;
04013         int argvi = 0;
04014         dXSARGS;
04015         
04016         if ((items < 3) || (items > 3)) {
04017             SWIG_croak("Usage: Database_get_doc(self,id,options);");
04018         }
04019         {
04020             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
04021                 SWIG_croak("Type error in argument 1 of Database_get_doc. Expected _p_estraier__Database");
04022             }
04023         }
04024         arg2 = (int) SvIV(ST(1));
04025         arg3 = (int) SvIV(ST(2));
04026         {
04027             try {
04028                 result = (estraier::Document *)(arg1)->get_doc(arg2,arg3);
04029                 
04030             } catch (const char *msg) {
04031                 SWIG_exception(SWIG_RuntimeError, msg);
04032             }
04033         }
04034         ST(argvi) = sv_newmortal();
04035         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|0);
04036         XSRETURN(argvi);
04037         fail:
04038         ;
04039     }
04040     croak(Nullch);
04041 }

XS _wrap_Database_out_doc   ) 
 

Definition at line 3970 of file HyperEstraier_wrap.cpp.

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

03970                            {
03971     {
03972         estraier::Database *arg1 = (estraier::Database *) 0 ;
03973         int arg2 ;
03974         int arg3 ;
03975         bool result;
03976         int argvi = 0;
03977         dXSARGS;
03978         
03979         if ((items < 3) || (items > 3)) {
03980             SWIG_croak("Usage: Database_out_doc(self,id,options);");
03981         }
03982         {
03983             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03984                 SWIG_croak("Type error in argument 1 of Database_out_doc. Expected _p_estraier__Database");
03985             }
03986         }
03987         arg2 = (int) SvIV(ST(1));
03988         arg3 = (int) SvIV(ST(2));
03989         {
03990             try {
03991                 result = (bool)(arg1)->out_doc(arg2,arg3);
03992                 
03993             } catch (const char *msg) {
03994                 SWIG_exception(SWIG_RuntimeError, msg);
03995             }
03996         }
03997         ST(argvi) = sv_newmortal();
03998         sv_setiv(ST(argvi++), (IV) result);
03999         XSRETURN(argvi);
04000         fail:
04001         ;
04002     }
04003     croak(Nullch);
04004 }

XS _wrap_Database_optimize   ) 
 

Definition at line 3935 of file HyperEstraier_wrap.cpp.

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

03935                             {
03936     {
03937         estraier::Database *arg1 = (estraier::Database *) 0 ;
03938         int arg2 ;
03939         bool result;
03940         int argvi = 0;
03941         dXSARGS;
03942         
03943         if ((items < 2) || (items > 2)) {
03944             SWIG_croak("Usage: Database_optimize(self,options);");
03945         }
03946         {
03947             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03948                 SWIG_croak("Type error in argument 1 of Database_optimize. Expected _p_estraier__Database");
03949             }
03950         }
03951         arg2 = (int) SvIV(ST(1));
03952         {
03953             try {
03954                 result = (bool)(arg1)->optimize(arg2);
03955                 
03956             } catch (const char *msg) {
03957                 SWIG_exception(SWIG_RuntimeError, msg);
03958             }
03959         }
03960         ST(argvi) = sv_newmortal();
03961         sv_setiv(ST(argvi++), (IV) result);
03962         XSRETURN(argvi);
03963         fail:
03964         ;
03965     }
03966     croak(Nullch);
03967 }

XS _wrap_Database_sync   ) 
 

Definition at line 3902 of file HyperEstraier_wrap.cpp.

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

03902                         {
03903     {
03904         estraier::Database *arg1 = (estraier::Database *) 0 ;
03905         bool result;
03906         int argvi = 0;
03907         dXSARGS;
03908         
03909         if ((items < 1) || (items > 1)) {
03910             SWIG_croak("Usage: Database_sync(self);");
03911         }
03912         {
03913             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03914                 SWIG_croak("Type error in argument 1 of Database_sync. Expected _p_estraier__Database");
03915             }
03916         }
03917         {
03918             try {
03919                 result = (bool)(arg1)->sync();
03920                 
03921             } catch (const char *msg) {
03922                 SWIG_exception(SWIG_RuntimeError, msg);
03923             }
03924         }
03925         ST(argvi) = sv_newmortal();
03926         sv_setiv(ST(argvi++), (IV) result);
03927         XSRETURN(argvi);
03928         fail:
03929         ;
03930     }
03931     croak(Nullch);
03932 }

XS _wrap_Database_flush   ) 
 

Definition at line 3867 of file HyperEstraier_wrap.cpp.

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

03867                          {
03868     {
03869         estraier::Database *arg1 = (estraier::Database *) 0 ;
03870         int arg2 ;
03871         bool result;
03872         int argvi = 0;
03873         dXSARGS;
03874         
03875         if ((items < 2) || (items > 2)) {
03876             SWIG_croak("Usage: Database_flush(self,_max);");
03877         }
03878         {
03879             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03880                 SWIG_croak("Type error in argument 1 of Database_flush. Expected _p_estraier__Database");
03881             }
03882         }
03883         arg2 = (int) SvIV(ST(1));
03884         {
03885             try {
03886                 result = (bool)(arg1)->flush(arg2);
03887                 
03888             } catch (const char *msg) {
03889                 SWIG_exception(SWIG_RuntimeError, msg);
03890             }
03891         }
03892         ST(argvi) = sv_newmortal();
03893         sv_setiv(ST(argvi++), (IV) result);
03894         XSRETURN(argvi);
03895         fail:
03896         ;
03897     }
03898     croak(Nullch);
03899 }

XS _wrap_Database_fatal   ) 
 

Definition at line 3834 of file HyperEstraier_wrap.cpp.

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

03834                          {
03835     {
03836         estraier::Database *arg1 = (estraier::Database *) 0 ;
03837         bool result;
03838         int argvi = 0;
03839         dXSARGS;
03840         
03841         if ((items < 1) || (items > 1)) {
03842             SWIG_croak("Usage: Database_fatal(self);");
03843         }
03844         {
03845             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03846                 SWIG_croak("Type error in argument 1 of Database_fatal. Expected _p_estraier__Database");
03847             }
03848         }
03849         {
03850             try {
03851                 result = (bool)(arg1)->fatal();
03852                 
03853             } catch (const char *msg) {
03854                 SWIG_exception(SWIG_RuntimeError, msg);
03855             }
03856         }
03857         ST(argvi) = sv_newmortal();
03858         sv_setiv(ST(argvi++), (IV) result);
03859         XSRETURN(argvi);
03860         fail:
03861         ;
03862     }
03863     croak(Nullch);
03864 }

XS _wrap_Database_error   ) 
 

Definition at line 3801 of file HyperEstraier_wrap.cpp.

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

03801                          {
03802     {
03803         estraier::Database *arg1 = (estraier::Database *) 0 ;
03804         int result;
03805         int argvi = 0;
03806         dXSARGS;
03807         
03808         if ((items < 1) || (items > 1)) {
03809             SWIG_croak("Usage: Database_error(self);");
03810         }
03811         {
03812             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03813                 SWIG_croak("Type error in argument 1 of Database_error. Expected _p_estraier__Database");
03814             }
03815         }
03816         {
03817             try {
03818                 result = (int)(arg1)->error();
03819                 
03820             } catch (const char *msg) {
03821                 SWIG_exception(SWIG_RuntimeError, msg);
03822             }
03823         }
03824         ST(argvi) = sv_newmortal();
03825         sv_setiv(ST(argvi++), (IV) result);
03826         XSRETURN(argvi);
03827         fail:
03828         ;
03829     }
03830     croak(Nullch);
03831 }

XS _wrap_Database_err_msg   ) 
 

Definition at line 3768 of file HyperEstraier_wrap.cpp.

References PL_sv_undef, SWIG_croak, SWIG_exception, and SWIG_RuntimeError.

03768                            {
03769     {
03770         int arg1 ;
03771         char *result;
03772         int argvi = 0;
03773         dXSARGS;
03774         
03775         if ((items < 1) || (items > 1)) {
03776             SWIG_croak("Usage: Database_err_msg(ecode);");
03777         }
03778         arg1 = (int) SvIV(ST(0));
03779         {
03780             try {
03781                 result = (char *)estraier::Database::err_msg(arg1);
03782                 
03783             } catch (const char *msg) {
03784                 SWIG_exception(SWIG_RuntimeError, msg);
03785             }
03786         }
03787         ST(argvi) = sv_newmortal();
03788         if (result) {
03789             sv_setpv((SV*)ST(argvi++), (char *) result);
03790         } else {
03791             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
03792         }
03793         XSRETURN(argvi);
03794         fail:
03795         ;
03796     }
03797     croak(Nullch);
03798 }

XS _wrap_Database_search   ) 
 

Definition at line 3727 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, SWIGTYPE_p_estraier__Condition, SWIGTYPE_p_estraier__Database, and SWIGTYPE_p_std__vectorTint_t.

03727                           {
03728     {
03729         estraier::Database *arg1 = (estraier::Database *) 0 ;
03730         estraier::Condition *arg2 = (estraier::Condition *) 0 ;
03731         int arg3 ;
03732         std::vector<int > *result;
03733         int argvi = 0;
03734         dXSARGS;
03735         
03736         if ((items < 3) || (items > 3)) {
03737             SWIG_croak("Usage: Database_search(self,cond,options);");
03738         }
03739         {
03740             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03741                 SWIG_croak("Type error in argument 1 of Database_search. Expected _p_estraier__Database");
03742             }
03743         }
03744         {
03745             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_estraier__Condition,0) < 0) {
03746                 SWIG_croak("Type error in argument 2 of Database_search. Expected _p_estraier__Condition");
03747             }
03748         }
03749         arg3 = (int) SvIV(ST(2));
03750         {
03751             try {
03752                 result = (std::vector<int > *)(arg1)->search(arg2,arg3);
03753                 
03754             } catch (const char *msg) {
03755                 SWIG_exception(SWIG_RuntimeError, msg);
03756             }
03757         }
03758         ST(argvi) = sv_newmortal();
03759         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|0);
03760         XSRETURN(argvi);
03761         fail:
03762         ;
03763     }
03764     croak(Nullch);
03765 }

XS _wrap_Database_put_doc   ) 
 

Definition at line 3686 of file HyperEstraier_wrap.cpp.

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

03686                            {
03687     {
03688         estraier::Database *arg1 = (estraier::Database *) 0 ;
03689         estraier::Document *arg2 = (estraier::Document *) 0 ;
03690         int arg3 ;
03691         bool result;
03692         int argvi = 0;
03693         dXSARGS;
03694         
03695         if ((items < 3) || (items > 3)) {
03696             SWIG_croak("Usage: Database_put_doc(self,doc,options);");
03697         }
03698         {
03699             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03700                 SWIG_croak("Type error in argument 1 of Database_put_doc. Expected _p_estraier__Database");
03701             }
03702         }
03703         {
03704             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_estraier__Document,0) < 0) {
03705                 SWIG_croak("Type error in argument 2 of Database_put_doc. Expected _p_estraier__Document");
03706             }
03707         }
03708         arg3 = (int) SvIV(ST(2));
03709         {
03710             try {
03711                 result = (bool)(arg1)->put_doc(arg2,arg3);
03712                 
03713             } catch (const char *msg) {
03714                 SWIG_exception(SWIG_RuntimeError, msg);
03715             }
03716         }
03717         ST(argvi) = sv_newmortal();
03718         sv_setiv(ST(argvi++), (IV) result);
03719         XSRETURN(argvi);
03720         fail:
03721         ;
03722     }
03723     croak(Nullch);
03724 }

XS _wrap_Database_close   ) 
 

Definition at line 3653 of file HyperEstraier_wrap.cpp.

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

03653                          {
03654     {
03655         estraier::Database *arg1 = (estraier::Database *) 0 ;
03656         bool result;
03657         int argvi = 0;
03658         dXSARGS;
03659         
03660         if ((items < 1) || (items > 1)) {
03661             SWIG_croak("Usage: Database_close(self);");
03662         }
03663         {
03664             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03665                 SWIG_croak("Type error in argument 1 of Database_close. Expected _p_estraier__Database");
03666             }
03667         }
03668         {
03669             try {
03670                 result = (bool)(arg1)->close();
03671                 
03672             } catch (const char *msg) {
03673                 SWIG_exception(SWIG_RuntimeError, msg);
03674             }
03675         }
03676         ST(argvi) = sv_newmortal();
03677         sv_setiv(ST(argvi++), (IV) result);
03678         XSRETURN(argvi);
03679         fail:
03680         ;
03681     }
03682     croak(Nullch);
03683 }

XS _wrap_Database_open   ) 
 

Definition at line 3615 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Database.

03615                         {
03616     {
03617         estraier::Database *arg1 = (estraier::Database *) 0 ;
03618         char *arg2 = (char *) 0 ;
03619         int arg3 ;
03620         bool result;
03621         int argvi = 0;
03622         dXSARGS;
03623         
03624         if ((items < 3) || (items > 3)) {
03625             SWIG_croak("Usage: Database_open(self,dbname,mode);");
03626         }
03627         {
03628             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03629                 SWIG_croak("Type error in argument 1 of Database_open. Expected _p_estraier__Database");
03630             }
03631         }
03632         if (!SvOK((SV*) ST(1))) arg2 = 0;
03633         else arg2 = (char *) SvPV(ST(1), PL_na);
03634         arg3 = (int) SvIV(ST(2));
03635         {
03636             try {
03637                 result = (bool)(arg1)->open((char const *)arg2,arg3);
03638                 
03639             } catch (const char *msg) {
03640                 SWIG_exception(SWIG_RuntimeError, msg);
03641             }
03642         }
03643         ST(argvi) = sv_newmortal();
03644         sv_setiv(ST(argvi++), (IV) result);
03645         XSRETURN(argvi);
03646         fail:
03647         ;
03648     }
03649     croak(Nullch);
03650 }

XS _wrap_delete_Database   ) 
 

Definition at line 3584 of file HyperEstraier_wrap.cpp.

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

03584                           {
03585     {
03586         estraier::Database *arg1 = (estraier::Database *) 0 ;
03587         int argvi = 0;
03588         dXSARGS;
03589         
03590         if ((items < 1) || (items > 1)) {
03591             SWIG_croak("Usage: delete_Database(self);");
03592         }
03593         {
03594             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
03595                 SWIG_croak("Type error in argument 1 of delete_Database. Expected _p_estraier__Database");
03596             }
03597         }
03598         {
03599             try {
03600                 delete arg1;
03601                 
03602             } catch (const char *msg) {
03603                 SWIG_exception(SWIG_RuntimeError, msg);
03604             }
03605         }
03606         
03607         XSRETURN(argvi);
03608         fail:
03609         ;
03610     }
03611     croak(Nullch);
03612 }

XS _wrap_new_Database   ) 
 

Definition at line 3557 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_estraier__Database.

03557                        {
03558     {
03559         estraier::Database *result;
03560         int argvi = 0;
03561         dXSARGS;
03562         
03563         if ((items < 0) || (items > 0)) {
03564             SWIG_croak("Usage: new_Database();");
03565         }
03566         {
03567             try {
03568                 result = (estraier::Database *)new estraier::Database();
03569                 
03570             } catch (const char *msg) {
03571                 SWIG_exception(SWIG_RuntimeError, msg);
03572             }
03573         }
03574         ST(argvi) = sv_newmortal();
03575         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Database, SWIG_SHADOW|SWIG_OWNER);
03576         XSRETURN(argvi);
03577         fail:
03578         ;
03579     }
03580     croak(Nullch);
03581 }

XS _wrap_Document_make_snippet   ) 
 

Definition at line 3486 of file HyperEstraier_wrap.cpp.

References PL_sv_undef, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__vectorTstd__string_t.

03486                                 {
03487     {
03488         estraier::Document *arg1 = (estraier::Document *) 0 ;
03489         std::vector<std::string > arg2 ;
03490         int arg3 ;
03491         int arg4 ;
03492         int arg5 ;
03493         char *result;
03494         std::vector<std::string > *v2 ;
03495         int argvi = 0;
03496         dXSARGS;
03497         
03498         if ((items < 5) || (items > 5)) {
03499             SWIG_croak("Usage: Document_make_snippet(self,_words,wwidth,hwidth,awidth);");
03500         }
03501         {
03502             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03503                 SWIG_croak("Type error in argument 1 of Document_make_snippet. Expected _p_estraier__Document");
03504             }
03505         }
03506         {
03507             if (SWIG_ConvertPtr(ST(1),(void **) &v2, 
03508             SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
03509                 arg2 = *v2;
03510             } else if (SvROK(ST(1))) {
03511                 AV *av = (AV *)SvRV(ST(1));
03512                 if (SvTYPE(av) != SVt_PVAV)
03513                 SWIG_croak("Type error in argument 2 of Document_make_snippet. "
03514                 "Expected an array of ""std::string");
03515                 SV **tv;
03516                 I32 len = av_len(av) + 1;
03517                 for (int i=0; i<len; i++) {
03518                     tv = av_fetch(av, i, 0);
03519                     if (SvPOK(*tv)) {
03520                         (&arg2)->push_back(SvPVX(*tv));
03521                     } else {
03522                         SWIG_croak("Type error in argument 2 of "
03523                         "Document_make_snippet. "
03524                         "Expected an array of ""std::string");
03525                     }
03526                 }
03527             } else {
03528                 SWIG_croak("Type error in argument 2 of Document_make_snippet. "
03529                 "Expected an array of ""std::string");
03530             }
03531         }
03532         arg3 = (int) SvIV(ST(2));
03533         arg4 = (int) SvIV(ST(3));
03534         arg5 = (int) SvIV(ST(4));
03535         {
03536             try {
03537                 result = (char *)(arg1)->make_snippet(arg2,arg3,arg4,arg5);
03538                 
03539             } catch (const char *msg) {
03540                 SWIG_exception(SWIG_RuntimeError, msg);
03541             }
03542         }
03543         ST(argvi) = sv_newmortal();
03544         if (result) {
03545             sv_setpv((SV*)ST(argvi++), (char *) result);
03546         } else {
03547             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
03548         }
03549         XSRETURN(argvi);
03550         fail:
03551         ;
03552     }
03553     croak(Nullch);
03554 }

XS _wrap_Document_dump_draft   ) 
 

Definition at line 3449 of file HyperEstraier_wrap.cpp.

References PL_sv_undef, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

03449                               {
03450     {
03451         estraier::Document *arg1 = (estraier::Document *) 0 ;
03452         char *result;
03453         int argvi = 0;
03454         dXSARGS;
03455         
03456         if ((items < 1) || (items > 1)) {
03457             SWIG_croak("Usage: Document_dump_draft(self);");
03458         }
03459         {
03460             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03461                 SWIG_croak("Type error in argument 1 of Document_dump_draft. Expected _p_estraier__Document");
03462             }
03463         }
03464         {
03465             try {
03466                 result = (char *)(arg1)->dump_draft();
03467                 
03468             } catch (const char *msg) {
03469                 SWIG_exception(SWIG_RuntimeError, msg);
03470             }
03471         }
03472         ST(argvi) = sv_newmortal();
03473         if (result) {
03474             sv_setpv((SV*)ST(argvi++), (char *) result);
03475         } else {
03476             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
03477         }
03478         XSRETURN(argvi);
03479         fail:
03480         ;
03481     }
03482     croak(Nullch);
03483 }

XS _wrap_Document_texts   ) 
 

Definition at line 3416 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__vectorTstd__string_t.

03416                          {
03417     {
03418         estraier::Document *arg1 = (estraier::Document *) 0 ;
03419         std::vector<std::string > *result;
03420         int argvi = 0;
03421         dXSARGS;
03422         
03423         if ((items < 1) || (items > 1)) {
03424             SWIG_croak("Usage: Document_texts(self);");
03425         }
03426         {
03427             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03428                 SWIG_croak("Type error in argument 1 of Document_texts. Expected _p_estraier__Document");
03429             }
03430         }
03431         {
03432             try {
03433                 result = (std::vector<std::string > *)(arg1)->texts();
03434                 
03435             } catch (const char *msg) {
03436                 SWIG_exception(SWIG_RuntimeError, msg);
03437             }
03438         }
03439         ST(argvi) = sv_newmortal();
03440         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
03441         XSRETURN(argvi);
03442         fail:
03443         ;
03444     }
03445     croak(Nullch);
03446 }

XS _wrap_Document_cat_texts   ) 
 

Definition at line 3379 of file HyperEstraier_wrap.cpp.

References PL_sv_undef, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

03379                              {
03380     {
03381         estraier::Document *arg1 = (estraier::Document *) 0 ;
03382         char *result;
03383         int argvi = 0;
03384         dXSARGS;
03385         
03386         if ((items < 1) || (items > 1)) {
03387             SWIG_croak("Usage: Document_cat_texts(self);");
03388         }
03389         {
03390             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03391                 SWIG_croak("Type error in argument 1 of Document_cat_texts. Expected _p_estraier__Document");
03392             }
03393         }
03394         {
03395             try {
03396                 result = (char *)(arg1)->cat_texts();
03397                 
03398             } catch (const char *msg) {
03399                 SWIG_exception(SWIG_RuntimeError, msg);
03400             }
03401         }
03402         ST(argvi) = sv_newmortal();
03403         if (result) {
03404             sv_setpv((SV*)ST(argvi++), (char *) result);
03405         } else {
03406             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
03407         }
03408         XSRETURN(argvi);
03409         fail:
03410         ;
03411     }
03412     croak(Nullch);
03413 }

XS _wrap_Document_attr   ) 
 

Definition at line 3339 of file HyperEstraier_wrap.cpp.

References PL_na, PL_sv_undef, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

03339                         {
03340     {
03341         estraier::Document *arg1 = (estraier::Document *) 0 ;
03342         char *arg2 = (char *) 0 ;
03343         char *result;
03344         int argvi = 0;
03345         dXSARGS;
03346         
03347         if ((items < 2) || (items > 2)) {
03348             SWIG_croak("Usage: Document_attr(self,name);");
03349         }
03350         {
03351             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03352                 SWIG_croak("Type error in argument 1 of Document_attr. Expected _p_estraier__Document");
03353             }
03354         }
03355         if (!SvOK((SV*) ST(1))) arg2 = 0;
03356         else arg2 = (char *) SvPV(ST(1), PL_na);
03357         {
03358             try {
03359                 result = (char *)(arg1)->attr((char const *)arg2);
03360                 
03361             } catch (const char *msg) {
03362                 SWIG_exception(SWIG_RuntimeError, msg);
03363             }
03364         }
03365         ST(argvi) = sv_newmortal();
03366         if (result) {
03367             sv_setpv((SV*)ST(argvi++), (char *) result);
03368         } else {
03369             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
03370         }
03371         XSRETURN(argvi);
03372         fail:
03373         ;
03374     }
03375     croak(Nullch);
03376 }

XS _wrap_Document_attr_names   ) 
 

Definition at line 3306 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, SWIGTYPE_p_estraier__Document, and SWIGTYPE_p_std__vectorTstd__string_t.

03306                               {
03307     {
03308         estraier::Document *arg1 = (estraier::Document *) 0 ;
03309         std::vector<std::string > *result;
03310         int argvi = 0;
03311         dXSARGS;
03312         
03313         if ((items < 1) || (items > 1)) {
03314             SWIG_croak("Usage: Document_attr_names(self);");
03315         }
03316         {
03317             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03318                 SWIG_croak("Type error in argument 1 of Document_attr_names. Expected _p_estraier__Document");
03319             }
03320         }
03321         {
03322             try {
03323                 result = (std::vector<std::string > *)(arg1)->attr_names();
03324                 
03325             } catch (const char *msg) {
03326                 SWIG_exception(SWIG_RuntimeError, msg);
03327             }
03328         }
03329         ST(argvi) = sv_newmortal();
03330         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
03331         XSRETURN(argvi);
03332         fail:
03333         ;
03334     }
03335     croak(Nullch);
03336 }

XS _wrap_Document_id   ) 
 

Definition at line 3273 of file HyperEstraier_wrap.cpp.

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

03273                       {
03274     {
03275         estraier::Document *arg1 = (estraier::Document *) 0 ;
03276         int result;
03277         int argvi = 0;
03278         dXSARGS;
03279         
03280         if ((items < 1) || (items > 1)) {
03281             SWIG_croak("Usage: Document_id(self);");
03282         }
03283         {
03284             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03285                 SWIG_croak("Type error in argument 1 of Document_id. Expected _p_estraier__Document");
03286             }
03287         }
03288         {
03289             try {
03290                 result = (int)(arg1)->id();
03291                 
03292             } catch (const char *msg) {
03293                 SWIG_exception(SWIG_RuntimeError, msg);
03294             }
03295         }
03296         ST(argvi) = sv_newmortal();
03297         sv_setiv(ST(argvi++), (IV) result);
03298         XSRETURN(argvi);
03299         fail:
03300         ;
03301     }
03302     croak(Nullch);
03303 }

XS _wrap_Document_add_hidden_text   ) 
 

Definition at line 3239 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

03239                                    {
03240     {
03241         estraier::Document *arg1 = (estraier::Document *) 0 ;
03242         char *arg2 = (char *) 0 ;
03243         int argvi = 0;
03244         dXSARGS;
03245         
03246         if ((items < 2) || (items > 2)) {
03247             SWIG_croak("Usage: Document_add_hidden_text(self,text);");
03248         }
03249         {
03250             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03251                 SWIG_croak("Type error in argument 1 of Document_add_hidden_text. Expected _p_estraier__Document");
03252             }
03253         }
03254         if (!SvOK((SV*) ST(1))) arg2 = 0;
03255         else arg2 = (char *) SvPV(ST(1), PL_na);
03256         {
03257             try {
03258                 (arg1)->add_hidden_text((char const *)arg2);
03259                 
03260             } catch (const char *msg) {
03261                 SWIG_exception(SWIG_RuntimeError, msg);
03262             }
03263         }
03264         
03265         XSRETURN(argvi);
03266         fail:
03267         ;
03268     }
03269     croak(Nullch);
03270 }

XS _wrap_Document_add_text   ) 
 

Definition at line 3205 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

03205                             {
03206     {
03207         estraier::Document *arg1 = (estraier::Document *) 0 ;
03208         char *arg2 = (char *) 0 ;
03209         int argvi = 0;
03210         dXSARGS;
03211         
03212         if ((items < 2) || (items > 2)) {
03213             SWIG_croak("Usage: Document_add_text(self,text);");
03214         }
03215         {
03216             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03217                 SWIG_croak("Type error in argument 1 of Document_add_text. Expected _p_estraier__Document");
03218             }
03219         }
03220         if (!SvOK((SV*) ST(1))) arg2 = 0;
03221         else arg2 = (char *) SvPV(ST(1), PL_na);
03222         {
03223             try {
03224                 (arg1)->add_text((char const *)arg2);
03225                 
03226             } catch (const char *msg) {
03227                 SWIG_exception(SWIG_RuntimeError, msg);
03228             }
03229         }
03230         
03231         XSRETURN(argvi);
03232         fail:
03233         ;
03234     }
03235     croak(Nullch);
03236 }

XS _wrap_Document_add_attr   ) 
 

Definition at line 3168 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Document.

03168                             {
03169     {
03170         estraier::Document *arg1 = (estraier::Document *) 0 ;
03171         char *arg2 = (char *) 0 ;
03172         char *arg3 = (char *) 0 ;
03173         int argvi = 0;
03174         dXSARGS;
03175         
03176         if ((items < 3) || (items > 3)) {
03177             SWIG_croak("Usage: Document_add_attr(self,name,value);");
03178         }
03179         {
03180             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03181                 SWIG_croak("Type error in argument 1 of Document_add_attr. Expected _p_estraier__Document");
03182             }
03183         }
03184         if (!SvOK((SV*) ST(1))) arg2 = 0;
03185         else arg2 = (char *) SvPV(ST(1), PL_na);
03186         if (!SvOK((SV*) ST(2))) arg3 = 0;
03187         else arg3 = (char *) SvPV(ST(2), PL_na);
03188         {
03189             try {
03190                 (arg1)->add_attr((char const *)arg2,(char const *)arg3);
03191                 
03192             } catch (const char *msg) {
03193                 SWIG_exception(SWIG_RuntimeError, msg);
03194             }
03195         }
03196         
03197         XSRETURN(argvi);
03198         fail:
03199         ;
03200     }
03201     croak(Nullch);
03202 }

XS _wrap_delete_Document   ) 
 

Definition at line 3137 of file HyperEstraier_wrap.cpp.

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

03137                           {
03138     {
03139         estraier::Document *arg1 = (estraier::Document *) 0 ;
03140         int argvi = 0;
03141         dXSARGS;
03142         
03143         if ((items < 1) || (items > 1)) {
03144             SWIG_croak("Usage: delete_Document(self);");
03145         }
03146         {
03147             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
03148                 SWIG_croak("Type error in argument 1 of delete_Document. Expected _p_estraier__Document");
03149             }
03150         }
03151         {
03152             try {
03153                 delete arg1;
03154                 
03155             } catch (const char *msg) {
03156                 SWIG_exception(SWIG_RuntimeError, msg);
03157             }
03158         }
03159         
03160         XSRETURN(argvi);
03161         fail:
03162         ;
03163     }
03164     croak(Nullch);
03165 }

XS _wrap_new_Document   ) 
 

Definition at line 3102 of file HyperEstraier_wrap.cpp.

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

03102                        {
03103     dXSARGS;
03104     
03105     if (items == 0) {
03106         (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_0); return;
03107     }
03108     if (items == 1) {
03109         int _v;
03110         {
03111             void *tmp;
03112             if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ESTDOC, 0) == -1) {
03113                 _v = 0;
03114             } else {
03115                 _v = 1;
03116             }
03117         }
03118         if (_v) {
03119             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_2); return;
03120         }
03121     }
03122     if (items == 1) {
03123         int _v;
03124         {
03125             _v = SvPOK(ST(0)) ? 1 : 0;
03126         }
03127         if (_v) {
03128             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_1); return;
03129         }
03130     }
03131     
03132     croak("No matching function for overloaded 'new_Document'");
03133     XSRETURN(0);
03134 }

XS _wrap_new_Document__SWIG_2   ) 
 

Definition at line 3069 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, SWIGTYPE_p_ESTDOC, and SWIGTYPE_p_estraier__Document.

03069                                {
03070     {
03071         ESTDOC *arg1 = (ESTDOC *) 0 ;
03072         estraier::Document *result;
03073         int argvi = 0;
03074         dXSARGS;
03075         
03076         if ((items < 1) || (items > 1)) {
03077             SWIG_croak("Usage: new_Document(_doc);");
03078         }
03079         {
03080             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ESTDOC,0) < 0) {
03081                 SWIG_croak("Type error in argument 1 of new_Document. Expected _p_ESTDOC");
03082             }
03083         }
03084         {
03085             try {
03086                 result = (estraier::Document *)new estraier::Document(arg1);
03087                 
03088             } catch (const char *msg) {
03089                 SWIG_exception(SWIG_RuntimeError, msg);
03090             }
03091         }
03092         ST(argvi) = sv_newmortal();
03093         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
03094         XSRETURN(argvi);
03095         fail:
03096         ;
03097     }
03098     croak(Nullch);
03099 }

XS _wrap_new_Document__SWIG_1   ) 
 

Definition at line 3039 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_estraier__Document.

03039                                {
03040     {
03041         char *arg1 = (char *) 0 ;
03042         estraier::Document *result;
03043         int argvi = 0;
03044         dXSARGS;
03045         
03046         if ((items < 1) || (items > 1)) {
03047             SWIG_croak("Usage: new_Document(draft);");
03048         }
03049         if (!SvOK((SV*) ST(0))) arg1 = 0;
03050         else arg1 = (char *) SvPV(ST(0), PL_na);
03051         {
03052             try {
03053                 result = (estraier::Document *)new estraier::Document((char const *)arg1);
03054                 
03055             } catch (const char *msg) {
03056                 SWIG_exception(SWIG_RuntimeError, msg);
03057             }
03058         }
03059         ST(argvi) = sv_newmortal();
03060         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
03061         XSRETURN(argvi);
03062         fail:
03063         ;
03064     }
03065     croak(Nullch);
03066 }

XS _wrap_new_Document__SWIG_0   ) 
 

Definition at line 3012 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_estraier__Document.

03012                                {
03013     {
03014         estraier::Document *result;
03015         int argvi = 0;
03016         dXSARGS;
03017         
03018         if ((items < 0) || (items > 0)) {
03019             SWIG_croak("Usage: new_Document();");
03020         }
03021         {
03022             try {
03023                 result = (estraier::Document *)new estraier::Document();
03024                 
03025             } catch (const char *msg) {
03026                 SWIG_exception(SWIG_RuntimeError, msg);
03027             }
03028         }
03029         ST(argvi) = sv_newmortal();
03030         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
03031         XSRETURN(argvi);
03032         fail:
03033         ;
03034     }
03035     croak(Nullch);
03036 }

XS _wrap_Document_doc_get   ) 
 

Definition at line 2985 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_MakePtr, SWIGTYPE_p_ESTDOC, and SWIGTYPE_p_estraier__Document.

02985                            {
02986     {
02987         estraier::Document *arg1 = (estraier::Document *) 0 ;
02988         ESTDOC *result;
02989         int argvi = 0;
02990         dXSARGS;
02991         
02992         if ((items < 1) || (items > 1)) {
02993             SWIG_croak("Usage: Document_doc_get(self);");
02994         }
02995         {
02996             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
02997                 SWIG_croak("Type error in argument 1 of Document_doc_get. Expected _p_estraier__Document");
02998             }
02999         }
03000         result = (ESTDOC *) ((arg1)->doc);
03001         
03002         ST(argvi) = sv_newmortal();
03003         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ESTDOC, 0|0);
03004         XSRETURN(argvi);
03005         fail:
03006         ;
03007     }
03008     croak(Nullch);
03009 }

XS _wrap_Document_doc_set   ) 
 

Definition at line 2954 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIGTYPE_p_ESTDOC, and SWIGTYPE_p_estraier__Document.

02954                            {
02955     {
02956         estraier::Document *arg1 = (estraier::Document *) 0 ;
02957         ESTDOC *arg2 = (ESTDOC *) 0 ;
02958         int argvi = 0;
02959         dXSARGS;
02960         
02961         if ((items < 2) || (items > 2)) {
02962             SWIG_croak("Usage: Document_doc_set(self,doc);");
02963         }
02964         {
02965             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
02966                 SWIG_croak("Type error in argument 1 of Document_doc_set. Expected _p_estraier__Document");
02967             }
02968         }
02969         {
02970             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ESTDOC,0) < 0) {
02971                 SWIG_croak("Type error in argument 2 of Document_doc_set. Expected _p_ESTDOC");
02972             }
02973         }
02974         if (arg1) (arg1)->doc = arg2;
02975         
02976         
02977         XSRETURN(argvi);
02978         fail:
02979         ;
02980     }
02981     croak(Nullch);
02982 }

XS _wrap_Condition_set_options   ) 
 

Definition at line 2921 of file HyperEstraier_wrap.cpp.

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

02921                                 {
02922     {
02923         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02924         int arg2 ;
02925         int argvi = 0;
02926         dXSARGS;
02927         
02928         if ((items < 2) || (items > 2)) {
02929             SWIG_croak("Usage: Condition_set_options(self,options);");
02930         }
02931         {
02932             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02933                 SWIG_croak("Type error in argument 1 of Condition_set_options. Expected _p_estraier__Condition");
02934             }
02935         }
02936         arg2 = (int) SvIV(ST(1));
02937         {
02938             try {
02939                 (arg1)->set_options(arg2);
02940                 
02941             } catch (const char *msg) {
02942                 SWIG_exception(SWIG_RuntimeError, msg);
02943             }
02944         }
02945         
02946         XSRETURN(argvi);
02947         fail:
02948         ;
02949     }
02950     croak(Nullch);
02951 }

XS _wrap_Condition_set_max   ) 
 

Definition at line 2888 of file HyperEstraier_wrap.cpp.

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

02888                             {
02889     {
02890         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02891         int arg2 ;
02892         int argvi = 0;
02893         dXSARGS;
02894         
02895         if ((items < 2) || (items > 2)) {
02896             SWIG_croak("Usage: Condition_set_max(self,_max);");
02897         }
02898         {
02899             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02900                 SWIG_croak("Type error in argument 1 of Condition_set_max. Expected _p_estraier__Condition");
02901             }
02902         }
02903         arg2 = (int) SvIV(ST(1));
02904         {
02905             try {
02906                 (arg1)->set_max(arg2);
02907                 
02908             } catch (const char *msg) {
02909                 SWIG_exception(SWIG_RuntimeError, msg);
02910             }
02911         }
02912         
02913         XSRETURN(argvi);
02914         fail:
02915         ;
02916     }
02917     croak(Nullch);
02918 }

XS _wrap_Condition_set_order   ) 
 

Definition at line 2854 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

02854                               {
02855     {
02856         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02857         char *arg2 = (char *) 0 ;
02858         int argvi = 0;
02859         dXSARGS;
02860         
02861         if ((items < 2) || (items > 2)) {
02862             SWIG_croak("Usage: Condition_set_order(self,expr);");
02863         }
02864         {
02865             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02866                 SWIG_croak("Type error in argument 1 of Condition_set_order. Expected _p_estraier__Condition");
02867             }
02868         }
02869         if (!SvOK((SV*) ST(1))) arg2 = 0;
02870         else arg2 = (char *) SvPV(ST(1), PL_na);
02871         {
02872             try {
02873                 (arg1)->set_order((char const *)arg2);
02874                 
02875             } catch (const char *msg) {
02876                 SWIG_exception(SWIG_RuntimeError, msg);
02877             }
02878         }
02879         
02880         XSRETURN(argvi);
02881         fail:
02882         ;
02883     }
02884     croak(Nullch);
02885 }

XS _wrap_Condition_add_attr   ) 
 

Definition at line 2820 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

02820                              {
02821     {
02822         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02823         char *arg2 = (char *) 0 ;
02824         int argvi = 0;
02825         dXSARGS;
02826         
02827         if ((items < 2) || (items > 2)) {
02828             SWIG_croak("Usage: Condition_add_attr(self,expr);");
02829         }
02830         {
02831             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02832                 SWIG_croak("Type error in argument 1 of Condition_add_attr. Expected _p_estraier__Condition");
02833             }
02834         }
02835         if (!SvOK((SV*) ST(1))) arg2 = 0;
02836         else arg2 = (char *) SvPV(ST(1), PL_na);
02837         {
02838             try {
02839                 (arg1)->add_attr((char const *)arg2);
02840                 
02841             } catch (const char *msg) {
02842                 SWIG_exception(SWIG_RuntimeError, msg);
02843             }
02844         }
02845         
02846         XSRETURN(argvi);
02847         fail:
02848         ;
02849     }
02850     croak(Nullch);
02851 }

XS _wrap_Condition_set_phrase   ) 
 

Definition at line 2786 of file HyperEstraier_wrap.cpp.

References PL_na, SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_estraier__Condition.

02786                                {
02787     {
02788         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02789         char *arg2 = (char *) 0 ;
02790         int argvi = 0;
02791         dXSARGS;
02792         
02793         if ((items < 2) || (items > 2)) {
02794             SWIG_croak("Usage: Condition_set_phrase(self,phrase);");
02795         }
02796         {
02797             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02798                 SWIG_croak("Type error in argument 1 of Condition_set_phrase. Expected _p_estraier__Condition");
02799             }
02800         }
02801         if (!SvOK((SV*) ST(1))) arg2 = 0;
02802         else arg2 = (char *) SvPV(ST(1), PL_na);
02803         {
02804             try {
02805                 (arg1)->set_phrase((char const *)arg2);
02806                 
02807             } catch (const char *msg) {
02808                 SWIG_exception(SWIG_RuntimeError, msg);
02809             }
02810         }
02811         
02812         XSRETURN(argvi);
02813         fail:
02814         ;
02815     }
02816     croak(Nullch);
02817 }

XS _wrap_delete_Condition   ) 
 

Definition at line 2755 of file HyperEstraier_wrap.cpp.

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

02755                            {
02756     {
02757         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02758         int argvi = 0;
02759         dXSARGS;
02760         
02761         if ((items < 1) || (items > 1)) {
02762             SWIG_croak("Usage: delete_Condition(self);");
02763         }
02764         {
02765             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02766                 SWIG_croak("Type error in argument 1 of delete_Condition. Expected _p_estraier__Condition");
02767             }
02768         }
02769         {
02770             try {
02771                 delete arg1;
02772                 
02773             } catch (const char *msg) {
02774                 SWIG_exception(SWIG_RuntimeError, msg);
02775             }
02776         }
02777         
02778         XSRETURN(argvi);
02779         fail:
02780         ;
02781     }
02782     croak(Nullch);
02783 }

XS _wrap_new_Condition   ) 
 

Definition at line 2728 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_estraier__Condition.

02728                         {
02729     {
02730         estraier::Condition *result;
02731         int argvi = 0;
02732         dXSARGS;
02733         
02734         if ((items < 0) || (items > 0)) {
02735             SWIG_croak("Usage: new_Condition();");
02736         }
02737         {
02738             try {
02739                 result = (estraier::Condition *)new estraier::Condition();
02740                 
02741             } catch (const char *msg) {
02742                 SWIG_exception(SWIG_RuntimeError, msg);
02743             }
02744         }
02745         ST(argvi) = sv_newmortal();
02746         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Condition, SWIG_SHADOW|SWIG_OWNER);
02747         XSRETURN(argvi);
02748         fail:
02749         ;
02750     }
02751     croak(Nullch);
02752 }

XS _wrap_Condition_cond_get   ) 
 

Definition at line 2701 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_MakePtr, SWIGTYPE_p_ESTCOND, and SWIGTYPE_p_estraier__Condition.

02701                              {
02702     {
02703         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02704         ESTCOND *result;
02705         int argvi = 0;
02706         dXSARGS;
02707         
02708         if ((items < 1) || (items > 1)) {
02709             SWIG_croak("Usage: Condition_cond_get(self);");
02710         }
02711         {
02712             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02713                 SWIG_croak("Type error in argument 1 of Condition_cond_get. Expected _p_estraier__Condition");
02714             }
02715         }
02716         result = (ESTCOND *) ((arg1)->cond);
02717         
02718         ST(argvi) = sv_newmortal();
02719         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ESTCOND, 0|0);
02720         XSRETURN(argvi);
02721         fail:
02722         ;
02723     }
02724     croak(Nullch);
02725 }

XS _wrap_Condition_cond_set   ) 
 

Definition at line 2670 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIGTYPE_p_ESTCOND, and SWIGTYPE_p_estraier__Condition.

02670                              {
02671     {
02672         estraier::Condition *arg1 = (estraier::Condition *) 0 ;
02673         ESTCOND *arg2 = (ESTCOND *) 0 ;
02674         int argvi = 0;
02675         dXSARGS;
02676         
02677         if ((items < 2) || (items > 2)) {
02678             SWIG_croak("Usage: Condition_cond_set(self,cond);");
02679         }
02680         {
02681             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
02682                 SWIG_croak("Type error in argument 1 of Condition_cond_set. Expected _p_estraier__Condition");
02683             }
02684         }
02685         {
02686             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ESTCOND,0) < 0) {
02687                 SWIG_croak("Type error in argument 2 of Condition_cond_set. Expected _p_ESTCOND");
02688             }
02689         }
02690         if (arg1) (arg1)->cond = arg2;
02691         
02692         
02693         XSRETURN(argvi);
02694         fail:
02695         ;
02696     }
02697     croak(Nullch);
02698 }

XS _wrap_delete_StrStrMap   ) 
 

Definition at line 2639 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02639                            {
02640     {
02641         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02642         int argvi = 0;
02643         dXSARGS;
02644         
02645         if ((items < 1) || (items > 1)) {
02646             SWIG_croak("Usage: delete_StrStrMap(self);");
02647         }
02648         {
02649             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02650                 SWIG_croak("Type error in argument 1 of delete_StrStrMap. Expected _p_std__mapTstd__string_std__string_t");
02651             }
02652         }
02653         {
02654             try {
02655                 delete arg1;
02656                 
02657             } catch (const char *msg) {
02658                 SWIG_exception(SWIG_RuntimeError, msg);
02659             }
02660         }
02661         
02662         XSRETURN(argvi);
02663         fail:
02664         ;
02665     }
02666     croak(Nullch);
02667 }

XS _wrap_StrStrMap_has_key   ) 
 

Definition at line 2594 of file HyperEstraier_wrap.cpp.

References std_map_Sl_std_string_Sc_std_string_Sg__has_key(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02594                             {
02595     {
02596         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02597         std::string *arg2 = 0 ;
02598         bool result;
02599         std::string temp2 ;
02600         int argvi = 0;
02601         dXSARGS;
02602         
02603         if ((items < 2) || (items > 2)) {
02604             SWIG_croak("Usage: StrStrMap_has_key(self,key);");
02605         }
02606         {
02607             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02608                 SWIG_croak("Type error in argument 1 of StrStrMap_has_key. Expected _p_std__mapTstd__string_std__string_t");
02609             }
02610         }
02611         {
02612             STRLEN len;
02613             const char *ptr = SvPV(ST(1), len);
02614             if (!ptr) {
02615                 SWIG_croak("Undefined variable in argument 2 of StrStrMap_has_key.");
02616             } else {
02617                 temp2.assign(ptr, len);
02618                 arg2 = &temp2;
02619             }
02620         }
02621         {
02622             try {
02623                 result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key(arg1,(std::string const &)*arg2);
02624                 
02625             } catch (const char *msg) {
02626                 SWIG_exception(SWIG_RuntimeError, msg);
02627             }
02628         }
02629         ST(argvi) = sv_newmortal();
02630         sv_setiv(ST(argvi++), (IV) result);
02631         XSRETURN(argvi);
02632         fail:
02633         ;
02634     }
02635     croak(Nullch);
02636 }

XS _wrap_StrStrMap_del   ) 
 

Definition at line 2551 of file HyperEstraier_wrap.cpp.

References std_map_Sl_std_string_Sc_std_string_Sg__del(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02551                         {
02552     {
02553         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02554         std::string *arg2 = 0 ;
02555         std::string temp2 ;
02556         int argvi = 0;
02557         dXSARGS;
02558         
02559         if ((items < 2) || (items > 2)) {
02560             SWIG_croak("Usage: StrStrMap_del(self,key);");
02561         }
02562         {
02563             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02564                 SWIG_croak("Type error in argument 1 of StrStrMap_del. Expected _p_std__mapTstd__string_std__string_t");
02565             }
02566         }
02567         {
02568             STRLEN len;
02569             const char *ptr = SvPV(ST(1), len);
02570             if (!ptr) {
02571                 SWIG_croak("Undefined variable in argument 2 of StrStrMap_del.");
02572             } else {
02573                 temp2.assign(ptr, len);
02574                 arg2 = &temp2;
02575             }
02576         }
02577         {
02578             try {
02579                 std_map_Sl_std_string_Sc_std_string_Sg__del(arg1,(std::string const &)*arg2);
02580                 
02581             } catch (std::out_of_range& e) {
02582                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02583             }
02584         }
02585         
02586         XSRETURN(argvi);
02587         fail:
02588         ;
02589     }
02590     croak(Nullch);
02591 }

XS _wrap_StrStrMap_set   ) 
 

Definition at line 2496 of file HyperEstraier_wrap.cpp.

References std_map_Sl_std_string_Sc_std_string_Sg__set(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02496                         {
02497     {
02498         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02499         std::string *arg2 = 0 ;
02500         std::string *arg3 = 0 ;
02501         std::string temp2 ;
02502         std::string temp3 ;
02503         int argvi = 0;
02504         dXSARGS;
02505         
02506         if ((items < 3) || (items > 3)) {
02507             SWIG_croak("Usage: StrStrMap_set(self,key,x);");
02508         }
02509         {
02510             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02511                 SWIG_croak("Type error in argument 1 of StrStrMap_set. Expected _p_std__mapTstd__string_std__string_t");
02512             }
02513         }
02514         {
02515             STRLEN len;
02516             const char *ptr = SvPV(ST(1), len);
02517             if (!ptr) {
02518                 SWIG_croak("Undefined variable in argument 2 of StrStrMap_set.");
02519             } else {
02520                 temp2.assign(ptr, len);
02521                 arg2 = &temp2;
02522             }
02523         }
02524         {
02525             STRLEN len;
02526             const char *ptr = SvPV(ST(2), len);
02527             if (!ptr) {
02528                 SWIG_croak("Undefined variable in argument 3 of StrStrMap_set.");
02529             } else {
02530                 temp3.assign(ptr, len);
02531                 arg3 = &temp3;
02532             }
02533         }
02534         {
02535             try {
02536                 std_map_Sl_std_string_Sc_std_string_Sg__set(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
02537                 
02538             } catch (const char *msg) {
02539                 SWIG_exception(SWIG_RuntimeError, msg);
02540             }
02541         }
02542         
02543         XSRETURN(argvi);
02544         fail:
02545         ;
02546     }
02547     croak(Nullch);
02548 }

XS _wrap_StrStrMap_get   ) 
 

Definition at line 2448 of file HyperEstraier_wrap.cpp.

References std_map_Sl_std_string_Sc_std_string_Sg__get(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_IndexError, SWIG_MakePtr, SWIGTYPE_p_std__mapTstd__string_std__string_t, and SWIGTYPE_p_std__string.

02448                         {
02449     {
02450         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02451         std::string *arg2 = 0 ;
02452         std::string *result;
02453         std::string temp2 ;
02454         int argvi = 0;
02455         dXSARGS;
02456         
02457         if ((items < 2) || (items > 2)) {
02458             SWIG_croak("Usage: StrStrMap_get(self,key);");
02459         }
02460         {
02461             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02462                 SWIG_croak("Type error in argument 1 of StrStrMap_get. Expected _p_std__mapTstd__string_std__string_t");
02463             }
02464         }
02465         {
02466             STRLEN len;
02467             const char *ptr = SvPV(ST(1), len);
02468             if (!ptr) {
02469                 SWIG_croak("Undefined variable in argument 2 of StrStrMap_get.");
02470             } else {
02471                 temp2.assign(ptr, len);
02472                 arg2 = &temp2;
02473             }
02474         }
02475         {
02476             try {
02477                 {
02478                     std::string &_result_ref = std_map_Sl_std_string_Sc_std_string_Sg__get(arg1,(std::string const &)*arg2);
02479                     result = (std::string *) &_result_ref;
02480                 }
02481                 
02482             } catch (std::out_of_range& e) {
02483                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02484             }
02485         }
02486         ST(argvi) = sv_newmortal();
02487         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__string, 0|0);
02488         XSRETURN(argvi);
02489         fail:
02490         ;
02491     }
02492     croak(Nullch);
02493 }

XS _wrap_StrStrMap_clear   ) 
 

Definition at line 2417 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02417                           {
02418     {
02419         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02420         int argvi = 0;
02421         dXSARGS;
02422         
02423         if ((items < 1) || (items > 1)) {
02424             SWIG_croak("Usage: StrStrMap_clear(self);");
02425         }
02426         {
02427             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02428                 SWIG_croak("Type error in argument 1 of StrStrMap_clear. Expected _p_std__mapTstd__string_std__string_t");
02429             }
02430         }
02431         {
02432             try {
02433                 (arg1)->clear();
02434                 
02435             } catch (const char *msg) {
02436                 SWIG_exception(SWIG_RuntimeError, msg);
02437             }
02438         }
02439         
02440         XSRETURN(argvi);
02441         fail:
02442         ;
02443     }
02444     croak(Nullch);
02445 }

XS _wrap_StrStrMap_empty   ) 
 

Definition at line 2384 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02384                           {
02385     {
02386         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02387         bool result;
02388         int argvi = 0;
02389         dXSARGS;
02390         
02391         if ((items < 1) || (items > 1)) {
02392             SWIG_croak("Usage: StrStrMap_empty(self);");
02393         }
02394         {
02395             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02396                 SWIG_croak("Type error in argument 1 of StrStrMap_empty. Expected _p_std__mapTstd__string_std__string_t");
02397             }
02398         }
02399         {
02400             try {
02401                 result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
02402                 
02403             } catch (const char *msg) {
02404                 SWIG_exception(SWIG_RuntimeError, msg);
02405             }
02406         }
02407         ST(argvi) = sv_newmortal();
02408         sv_setiv(ST(argvi++), (IV) result);
02409         XSRETURN(argvi);
02410         fail:
02411         ;
02412     }
02413     croak(Nullch);
02414 }

XS _wrap_StrStrMap_size   ) 
 

Definition at line 2351 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02351                          {
02352     {
02353         std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
02354         unsigned int result;
02355         int argvi = 0;
02356         dXSARGS;
02357         
02358         if ((items < 1) || (items > 1)) {
02359             SWIG_croak("Usage: StrStrMap_size(self);");
02360         }
02361         {
02362             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02363                 SWIG_croak("Type error in argument 1 of StrStrMap_size. Expected _p_std__mapTstd__string_std__string_t");
02364             }
02365         }
02366         {
02367             try {
02368                 result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
02369                 
02370             } catch (const char *msg) {
02371                 SWIG_exception(SWIG_RuntimeError, msg);
02372             }
02373         }
02374         ST(argvi) = sv_newmortal();
02375         sv_setuv(ST(argvi++), (UV) result);
02376         XSRETURN(argvi);
02377         fail:
02378         ;
02379     }
02380     croak(Nullch);
02381 }

XS _wrap_new_StrStrMap   ) 
 

Definition at line 2325 of file HyperEstraier_wrap.cpp.

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

02325                         {
02326     dXSARGS;
02327     
02328     if (items == 0) {
02329         (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrStrMap__SWIG_0); return;
02330     }
02331     if (items == 1) {
02332         int _v;
02333         {
02334             void *tmp;
02335             if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
02336                 _v = 0;
02337             } else {
02338                 _v = 1;
02339             }
02340         }
02341         if (_v) {
02342             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrStrMap__SWIG_1); return;
02343         }
02344     }
02345     
02346     croak("No matching function for overloaded 'new_StrStrMap'");
02347     XSRETURN(0);
02348 }

XS _wrap_new_StrStrMap__SWIG_1   ) 
 

Definition at line 2292 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02292                                 {
02293     {
02294         std::map<std::string,std::string > *arg1 = 0 ;
02295         std::map<std::string,std::string > *result;
02296         int argvi = 0;
02297         dXSARGS;
02298         
02299         if ((items < 1) || (items > 1)) {
02300             SWIG_croak("Usage: new_StrStrMap(std::map<std::string,std::string > const &);");
02301         }
02302         {
02303             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
02304                 SWIG_croak("Type error in argument 1 of new_StrStrMap. Expected _p_std__mapTstd__string_std__string_t");
02305             }
02306         }
02307         {
02308             try {
02309                 result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
02310                 
02311             } catch (const char *msg) {
02312                 SWIG_exception(SWIG_RuntimeError, msg);
02313             }
02314         }
02315         ST(argvi) = sv_newmortal();
02316         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|SWIG_OWNER);
02317         XSRETURN(argvi);
02318         fail:
02319         ;
02320     }
02321     croak(Nullch);
02322 }

XS _wrap_new_StrStrMap__SWIG_0   ) 
 

Definition at line 2265 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__mapTstd__string_std__string_t.

02265                                 {
02266     {
02267         std::map<std::string,std::string > *result;
02268         int argvi = 0;
02269         dXSARGS;
02270         
02271         if ((items < 0) || (items > 0)) {
02272             SWIG_croak("Usage: new_StrStrMap();");
02273         }
02274         {
02275             try {
02276                 result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
02277                 
02278             } catch (const char *msg) {
02279                 SWIG_exception(SWIG_RuntimeError, msg);
02280             }
02281         }
02282         ST(argvi) = sv_newmortal();
02283         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|SWIG_OWNER);
02284         XSRETURN(argvi);
02285         fail:
02286         ;
02287     }
02288     croak(Nullch);
02289 }

XS _wrap_delete_IntVector   ) 
 

Definition at line 2234 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

02234                            {
02235     {
02236         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02237         int argvi = 0;
02238         dXSARGS;
02239         
02240         if ((items < 1) || (items > 1)) {
02241             SWIG_croak("Usage: delete_IntVector(self);");
02242         }
02243         {
02244             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
02245                 SWIG_croak("Type error in argument 1 of delete_IntVector. Expected _p_std__vectorTint_t");
02246             }
02247         }
02248         {
02249             try {
02250                 delete arg1;
02251                 
02252             } catch (const char *msg) {
02253                 SWIG_exception(SWIG_RuntimeError, msg);
02254             }
02255         }
02256         
02257         XSRETURN(argvi);
02258         fail:
02259         ;
02260     }
02261     croak(Nullch);
02262 }

XS _wrap_IntVector_set   ) 
 

Definition at line 2199 of file HyperEstraier_wrap.cpp.

References std_vector_Sl_int_Sg__set(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTint_t.

02199                         {
02200     {
02201         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02202         int arg2 ;
02203         int arg3 ;
02204         int argvi = 0;
02205         dXSARGS;
02206         
02207         if ((items < 3) || (items > 3)) {
02208             SWIG_croak("Usage: IntVector_set(self,i,x);");
02209         }
02210         {
02211             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
02212                 SWIG_croak("Type error in argument 1 of IntVector_set. Expected _p_std__vectorTint_t");
02213             }
02214         }
02215         arg2 = (int) SvIV(ST(1));
02216         arg3 = (int) SvIV(ST(2));
02217         {
02218             try {
02219                 std_vector_Sl_int_Sg__set(arg1,arg2,arg3);
02220                 
02221             } catch (std::out_of_range& e) {
02222                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02223             }
02224         }
02225         
02226         XSRETURN(argvi);
02227         fail:
02228         ;
02229     }
02230     croak(Nullch);
02231 }

XS _wrap_IntVector_get   ) 
 

Definition at line 2164 of file HyperEstraier_wrap.cpp.

References std_vector_Sl_int_Sg__get(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTint_t.

02164                         {
02165     {
02166         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02167         int arg2 ;
02168         int result;
02169         int argvi = 0;
02170         dXSARGS;
02171         
02172         if ((items < 2) || (items > 2)) {
02173             SWIG_croak("Usage: IntVector_get(self,i);");
02174         }
02175         {
02176             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
02177                 SWIG_croak("Type error in argument 1 of IntVector_get. Expected _p_std__vectorTint_t");
02178             }
02179         }
02180         arg2 = (int) SvIV(ST(1));
02181         {
02182             try {
02183                 result = (int)std_vector_Sl_int_Sg__get(arg1,arg2);
02184                 
02185             } catch (std::out_of_range& e) {
02186                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02187             }
02188         }
02189         ST(argvi) = sv_newmortal();
02190         sv_setiv(ST(argvi++), (IV) result);
02191         XSRETURN(argvi);
02192         fail:
02193         ;
02194     }
02195     croak(Nullch);
02196 }

XS _wrap_IntVector_pop   ) 
 

Definition at line 2131 of file HyperEstraier_wrap.cpp.

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

02131                         {
02132     {
02133         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02134         int result;
02135         int argvi = 0;
02136         dXSARGS;
02137         
02138         if ((items < 1) || (items > 1)) {
02139             SWIG_croak("Usage: IntVector_pop(self);");
02140         }
02141         {
02142             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
02143                 SWIG_croak("Type error in argument 1 of IntVector_pop. Expected _p_std__vectorTint_t");
02144             }
02145         }
02146         {
02147             try {
02148                 result = (int)std_vector_Sl_int_Sg__pop(arg1);
02149                 
02150             } catch (std::out_of_range& e) {
02151                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
02152             }
02153         }
02154         ST(argvi) = sv_newmortal();
02155         sv_setiv(ST(argvi++), (IV) result);
02156         XSRETURN(argvi);
02157         fail:
02158         ;
02159     }
02160     croak(Nullch);
02161 }

XS _wrap_IntVector_push   ) 
 

Definition at line 2098 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

02098                          {
02099     {
02100         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02101         int arg2 ;
02102         int argvi = 0;
02103         dXSARGS;
02104         
02105         if ((items < 2) || (items > 2)) {
02106             SWIG_croak("Usage: IntVector_push(self,x);");
02107         }
02108         {
02109             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
02110                 SWIG_croak("Type error in argument 1 of IntVector_push. Expected _p_std__vectorTint_t");
02111             }
02112         }
02113         arg2 = (int) SvIV(ST(1));
02114         {
02115             try {
02116                 (arg1)->push_back(arg2);
02117                 
02118             } catch (const char *msg) {
02119                 SWIG_exception(SWIG_RuntimeError, msg);
02120             }
02121         }
02122         
02123         XSRETURN(argvi);
02124         fail:
02125         ;
02126     }
02127     croak(Nullch);
02128 }

XS _wrap_IntVector_clear   ) 
 

Definition at line 2067 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

02067                           {
02068     {
02069         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02070         int argvi = 0;
02071         dXSARGS;
02072         
02073         if ((items < 1) || (items > 1)) {
02074             SWIG_croak("Usage: IntVector_clear(self);");
02075         }
02076         {
02077             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
02078                 SWIG_croak("Type error in argument 1 of IntVector_clear. Expected _p_std__vectorTint_t");
02079             }
02080         }
02081         {
02082             try {
02083                 (arg1)->clear();
02084                 
02085             } catch (const char *msg) {
02086                 SWIG_exception(SWIG_RuntimeError, msg);
02087             }
02088         }
02089         
02090         XSRETURN(argvi);
02091         fail:
02092         ;
02093     }
02094     croak(Nullch);
02095 }

XS _wrap_IntVector_empty   ) 
 

Definition at line 2009 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

02009                           {
02010     {
02011         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
02012         bool result;
02013         std::vector<int > temp1 ;
02014         std::vector<int > *v1 ;
02015         int argvi = 0;
02016         dXSARGS;
02017         
02018         if ((items < 1) || (items > 1)) {
02019             SWIG_croak("Usage: IntVector_empty(self);");
02020         }
02021         {
02022             if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
02023             SWIGTYPE_p_std__vectorTint_t,1) != -1) {
02024                 arg1 = v1;
02025             } else if (SvROK(ST(0))) {
02026                 AV *av = (AV *)SvRV(ST(0));
02027                 if (SvTYPE(av) != SVt_PVAV)
02028                 SWIG_croak("Type error in argument 1 of IntVector_empty. "
02029                 "Expected an array of ""int");
02030                 SV **tv;
02031                 I32 len = av_len(av) + 1;
02032                 int* obj;
02033                 for (int i=0; i<len; i++) {
02034                     tv = av_fetch(av, i, 0);
02035                     if (SvIOK(*tv)) {
02036                         temp1.push_back(SvIVX(*tv));
02037                     } else {
02038                         SWIG_croak("Type error in argument 1 of "
02039                         "IntVector_empty. "
02040                         "Expected an array of ""int");
02041                     }
02042                 }
02043                 arg1 = &temp1;
02044             } else {
02045                 SWIG_croak("Type error in argument 1 of IntVector_empty. "
02046                 "Expected an array of ""int");
02047             }
02048         }
02049         {
02050             try {
02051                 result = (bool)((std::vector<int > const *)arg1)->empty();
02052                 
02053             } catch (const char *msg) {
02054                 SWIG_exception(SWIG_RuntimeError, msg);
02055             }
02056         }
02057         ST(argvi) = sv_newmortal();
02058         sv_setiv(ST(argvi++), (IV) result);
02059         XSRETURN(argvi);
02060         fail:
02061         ;
02062     }
02063     croak(Nullch);
02064 }

XS _wrap_IntVector_size   ) 
 

Definition at line 1951 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTint_t.

01951                          {
01952     {
01953         std::vector<int > *arg1 = (std::vector<int > *) 0 ;
01954         unsigned int result;
01955         std::vector<int > temp1 ;
01956         std::vector<int > *v1 ;
01957         int argvi = 0;
01958         dXSARGS;
01959         
01960         if ((items < 1) || (items > 1)) {
01961             SWIG_croak("Usage: IntVector_size(self);");
01962         }
01963         {
01964             if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
01965             SWIGTYPE_p_std__vectorTint_t,1) != -1) {
01966                 arg1 = v1;
01967             } else if (SvROK(ST(0))) {
01968                 AV *av = (AV *)SvRV(ST(0));
01969                 if (SvTYPE(av) != SVt_PVAV)
01970                 SWIG_croak("Type error in argument 1 of IntVector_size. "
01971                 "Expected an array of ""int");
01972                 SV **tv;
01973                 I32 len = av_len(av) + 1;
01974                 int* obj;
01975                 for (int i=0; i<len; i++) {
01976                     tv = av_fetch(av, i, 0);
01977                     if (SvIOK(*tv)) {
01978                         temp1.push_back(SvIVX(*tv));
01979                     } else {
01980                         SWIG_croak("Type error in argument 1 of "
01981                         "IntVector_size. "
01982                         "Expected an array of ""int");
01983                     }
01984                 }
01985                 arg1 = &temp1;
01986             } else {
01987                 SWIG_croak("Type error in argument 1 of IntVector_size. "
01988                 "Expected an array of ""int");
01989             }
01990         }
01991         {
01992             try {
01993                 result = (unsigned int)((std::vector<int > const *)arg1)->size();
01994                 
01995             } catch (const char *msg) {
01996                 SWIG_exception(SWIG_RuntimeError, msg);
01997             }
01998         }
01999         ST(argvi) = sv_newmortal();
02000         sv_setuv(ST(argvi++), (UV) result);
02001         XSRETURN(argvi);
02002         fail:
02003         ;
02004     }
02005     croak(Nullch);
02006 }

XS _wrap_new_IntVector   ) 
 

Definition at line 1880 of file HyperEstraier_wrap.cpp.

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

01880                         {
01881     dXSARGS;
01882     
01883     if (items == 0) {
01884         (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_1); return;
01885     }
01886     if (items == 1) {
01887         int _v;
01888         {
01889             _v = SvIOK(ST(0)) ? 1 : 0;
01890         }
01891         if (_v) {
01892             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_0); return;
01893         }
01894     }
01895     if (items == 1) {
01896         int _v;
01897         {
01898             {
01899                 /* wrapped vector? */
01900                 std::vector<int >* v;
01901                 if (SWIG_ConvertPtr(ST(0),(void **) &v, 
01902                 SWIGTYPE_p_std__vectorTint_t,0) != -1) {
01903                     _v = 1;
01904                 } else if (SvROK(ST(0))) {
01905                     /* native sequence? */
01906                     AV *av = (AV *)SvRV(ST(0));
01907                     if (SvTYPE(av) == SVt_PVAV) {
01908                         SV **tv;
01909                         I32 len = av_len(av) + 1;
01910                         if (len == 0) {
01911                             /* an empty sequence can be of any type */
01912                             _v = 1;
01913                         } else {
01914                             /* check the first element only */
01915                             tv = av_fetch(av, 0, 0);
01916                             if (SvIOK(*tv))
01917                             _v = 1;
01918                             else
01919                             _v = 0;
01920                         }
01921                     }
01922                 } else {
01923                     _v = 0;
01924                 }
01925             }
01926         }
01927         if (_v) {
01928             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_3); return;
01929         }
01930     }
01931     if (items == 2) {
01932         int _v;
01933         {
01934             _v = SvIOK(ST(0)) ? 1 : 0;
01935         }
01936         if (_v) {
01937             {
01938                 _v = SvIOK(ST(1)) ? 1 : 0;
01939             }
01940             if (_v) {
01941                 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_2); return;
01942             }
01943         }
01944     }
01945     
01946     croak("No matching function for overloaded 'new_IntVector'");
01947     XSRETURN(0);
01948 }

XS _wrap_new_IntVector__SWIG_3   ) 
 

Definition at line 1822 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTint_t.

01822                                 {
01823     {
01824         std::vector<int > *arg1 = 0 ;
01825         std::vector<int > *result;
01826         std::vector<int > temp1 ;
01827         std::vector<int > *v1 ;
01828         int argvi = 0;
01829         dXSARGS;
01830         
01831         if ((items < 1) || (items > 1)) {
01832             SWIG_croak("Usage: new_IntVector(std::vector<int > const &);");
01833         }
01834         {
01835             if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
01836             SWIGTYPE_p_std__vectorTint_t,1) != -1) {
01837                 arg1 = v1;
01838             } else if (SvROK(ST(0))) {
01839                 AV *av = (AV *)SvRV(ST(0));
01840                 if (SvTYPE(av) != SVt_PVAV)
01841                 SWIG_croak("Type error in argument 1 of new_IntVector. "
01842                 "Expected an array of ""int");
01843                 SV **tv;
01844                 I32 len = av_len(av) + 1;
01845                 int* obj;
01846                 for (int i=0; i<len; i++) {
01847                     tv = av_fetch(av, i, 0);
01848                     if (SvIOK(*tv)) {
01849                         temp1.push_back(SvIVX(*tv));
01850                     } else {
01851                         SWIG_croak("Type error in argument 1 of "
01852                         "new_IntVector. "
01853                         "Expected an array of ""int");
01854                     }
01855                 }
01856                 arg1 = &temp1;
01857             } else {
01858                 SWIG_croak("Type error in argument 1 of new_IntVector. "
01859                 "Expected an array of ""int");
01860             }
01861         }
01862         {
01863             try {
01864                 result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
01865                 
01866             } catch (const char *msg) {
01867                 SWIG_exception(SWIG_RuntimeError, msg);
01868             }
01869         }
01870         ST(argvi) = sv_newmortal();
01871         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
01872         XSRETURN(argvi);
01873         fail:
01874         ;
01875     }
01876     croak(Nullch);
01877 }

XS _wrap_new_IntVector__SWIG_2   ) 
 

Definition at line 1791 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTint_t.

01791                                 {
01792     {
01793         unsigned int arg1 ;
01794         int arg2 ;
01795         std::vector<int > *result;
01796         int argvi = 0;
01797         dXSARGS;
01798         
01799         if ((items < 2) || (items > 2)) {
01800             SWIG_croak("Usage: new_IntVector(size,value);");
01801         }
01802         arg1 = (unsigned int) SvUV(ST(0));
01803         arg2 = (int) SvIV(ST(1));
01804         {
01805             try {
01806                 result = (std::vector<int > *)new std::vector<int >(arg1,arg2);
01807                 
01808             } catch (const char *msg) {
01809                 SWIG_exception(SWIG_RuntimeError, msg);
01810             }
01811         }
01812         ST(argvi) = sv_newmortal();
01813         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
01814         XSRETURN(argvi);
01815         fail:
01816         ;
01817     }
01818     croak(Nullch);
01819 }

XS _wrap_new_IntVector__SWIG_1   ) 
 

Definition at line 1764 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTint_t.

01764                                 {
01765     {
01766         std::vector<int > *result;
01767         int argvi = 0;
01768         dXSARGS;
01769         
01770         if ((items < 0) || (items > 0)) {
01771             SWIG_croak("Usage: new_IntVector();");
01772         }
01773         {
01774             try {
01775                 result = (std::vector<int > *)new std::vector<int >();
01776                 
01777             } catch (const char *msg) {
01778                 SWIG_exception(SWIG_RuntimeError, msg);
01779             }
01780         }
01781         ST(argvi) = sv_newmortal();
01782         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|0);
01783         XSRETURN(argvi);
01784         fail:
01785         ;
01786     }
01787     croak(Nullch);
01788 }

XS _wrap_new_IntVector__SWIG_0   ) 
 

Definition at line 1735 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTint_t.

01735                                 {
01736     {
01737         unsigned int arg1 ;
01738         std::vector<int > *result;
01739         int argvi = 0;
01740         dXSARGS;
01741         
01742         if ((items < 1) || (items > 1)) {
01743             SWIG_croak("Usage: new_IntVector(size);");
01744         }
01745         arg1 = (unsigned int) SvUV(ST(0));
01746         {
01747             try {
01748                 result = (std::vector<int > *)new std::vector<int >(arg1);
01749                 
01750             } catch (const char *msg) {
01751                 SWIG_exception(SWIG_RuntimeError, msg);
01752             }
01753         }
01754         ST(argvi) = sv_newmortal();
01755         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
01756         XSRETURN(argvi);
01757         fail:
01758         ;
01759     }
01760     croak(Nullch);
01761 }

XS _wrap_delete_StrVector   ) 
 

Definition at line 1704 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

01704                            {
01705     {
01706         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01707         int argvi = 0;
01708         dXSARGS;
01709         
01710         if ((items < 1) || (items > 1)) {
01711             SWIG_croak("Usage: delete_StrVector(self);");
01712         }
01713         {
01714             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
01715                 SWIG_croak("Type error in argument 1 of delete_StrVector. Expected _p_std__vectorTstd__string_t");
01716             }
01717         }
01718         {
01719             try {
01720                 delete arg1;
01721                 
01722             } catch (const char *msg) {
01723                 SWIG_exception(SWIG_RuntimeError, msg);
01724             }
01725         }
01726         
01727         XSRETURN(argvi);
01728         fail:
01729         ;
01730     }
01731     croak(Nullch);
01732 }

XS _wrap_StrVector_set   ) 
 

Definition at line 1661 of file HyperEstraier_wrap.cpp.

References std_vector_Sl_std_string_Sg__set(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTstd__string_t.

01661                         {
01662     {
01663         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01664         int arg2 ;
01665         std::string arg3 ;
01666         int argvi = 0;
01667         dXSARGS;
01668         
01669         if ((items < 3) || (items > 3)) {
01670             SWIG_croak("Usage: StrVector_set(self,i,x);");
01671         }
01672         {
01673             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
01674                 SWIG_croak("Type error in argument 1 of StrVector_set. Expected _p_std__vectorTstd__string_t");
01675             }
01676         }
01677         arg2 = (int) SvIV(ST(1));
01678         {
01679             STRLEN len;
01680             const char *ptr = SvPV(ST(2), len);
01681             if (!ptr) {
01682                 SWIG_croak("Undefined variable in argument 3 of StrVector_set.");
01683             } else {
01684                 arg3 = std::string(ptr, len);
01685             }
01686         }
01687         {
01688             try {
01689                 std_vector_Sl_std_string_Sg__set(arg1,arg2,arg3);
01690                 
01691             } catch (std::out_of_range& e) {
01692                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01693             }
01694         }
01695         
01696         XSRETURN(argvi);
01697         fail:
01698         ;
01699     }
01700     croak(Nullch);
01701 }

XS _wrap_StrVector_get   ) 
 

Definition at line 1622 of file HyperEstraier_wrap.cpp.

References std_vector_Sl_std_string_Sg__get(), SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_IndexError, and SWIGTYPE_p_std__vectorTstd__string_t.

01622                         {
01623     {
01624         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01625         int arg2 ;
01626         std::string result;
01627         int argvi = 0;
01628         dXSARGS;
01629         
01630         if ((items < 2) || (items > 2)) {
01631             SWIG_croak("Usage: StrVector_get(self,i);");
01632         }
01633         {
01634             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
01635                 SWIG_croak("Type error in argument 1 of StrVector_get. Expected _p_std__vectorTstd__string_t");
01636             }
01637         }
01638         arg2 = (int) SvIV(ST(1));
01639         {
01640             try {
01641                 result = std_vector_Sl_std_string_Sg__get(arg1,arg2);
01642                 
01643             } catch (std::out_of_range& e) {
01644                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01645             }
01646         }
01647         {
01648             if (argvi >= items) EXTEND(sp, 1);  // bump stack ptr, if needed
01649             char *data = const_cast<char*>((&result)->data());
01650             sv_setpvn(ST(argvi) = sv_newmortal(), data, (&result)->size());
01651             ++argvi;
01652         }
01653         XSRETURN(argvi);
01654         fail:
01655         ;
01656     }
01657     croak(Nullch);
01658 }

XS _wrap_StrVector_pop   ) 
 

Definition at line 1585 of file HyperEstraier_wrap.cpp.

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

01585                         {
01586     {
01587         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01588         std::string result;
01589         int argvi = 0;
01590         dXSARGS;
01591         
01592         if ((items < 1) || (items > 1)) {
01593             SWIG_croak("Usage: StrVector_pop(self);");
01594         }
01595         {
01596             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
01597                 SWIG_croak("Type error in argument 1 of StrVector_pop. Expected _p_std__vectorTstd__string_t");
01598             }
01599         }
01600         {
01601             try {
01602                 result = std_vector_Sl_std_string_Sg__pop(arg1);
01603                 
01604             } catch (std::out_of_range& e) {
01605                 SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
01606             }
01607         }
01608         {
01609             if (argvi >= items) EXTEND(sp, 1);  // bump stack ptr, if needed
01610             char *data = const_cast<char*>((&result)->data());
01611             sv_setpvn(ST(argvi) = sv_newmortal(), data, (&result)->size());
01612             ++argvi;
01613         }
01614         XSRETURN(argvi);
01615         fail:
01616         ;
01617     }
01618     croak(Nullch);
01619 }

XS _wrap_StrVector_push   ) 
 

Definition at line 1544 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

01544                          {
01545     {
01546         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01547         std::string arg2 ;
01548         int argvi = 0;
01549         dXSARGS;
01550         
01551         if ((items < 2) || (items > 2)) {
01552             SWIG_croak("Usage: StrVector_push(self,x);");
01553         }
01554         {
01555             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
01556                 SWIG_croak("Type error in argument 1 of StrVector_push. Expected _p_std__vectorTstd__string_t");
01557             }
01558         }
01559         {
01560             STRLEN len;
01561             const char *ptr = SvPV(ST(1), len);
01562             if (!ptr) {
01563                 SWIG_croak("Undefined variable in argument 2 of StrVector_push.");
01564             } else {
01565                 arg2 = std::string(ptr, len);
01566             }
01567         }
01568         {
01569             try {
01570                 (arg1)->push_back(arg2);
01571                 
01572             } catch (const char *msg) {
01573                 SWIG_exception(SWIG_RuntimeError, msg);
01574             }
01575         }
01576         
01577         XSRETURN(argvi);
01578         fail:
01579         ;
01580     }
01581     croak(Nullch);
01582 }

XS _wrap_StrVector_clear   ) 
 

Definition at line 1513 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

01513                           {
01514     {
01515         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01516         int argvi = 0;
01517         dXSARGS;
01518         
01519         if ((items < 1) || (items > 1)) {
01520             SWIG_croak("Usage: StrVector_clear(self);");
01521         }
01522         {
01523             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
01524                 SWIG_croak("Type error in argument 1 of StrVector_clear. Expected _p_std__vectorTstd__string_t");
01525             }
01526         }
01527         {
01528             try {
01529                 (arg1)->clear();
01530                 
01531             } catch (const char *msg) {
01532                 SWIG_exception(SWIG_RuntimeError, msg);
01533             }
01534         }
01535         
01536         XSRETURN(argvi);
01537         fail:
01538         ;
01539     }
01540     croak(Nullch);
01541 }

XS _wrap_StrVector_empty   ) 
 

Definition at line 1455 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

01455                           {
01456     {
01457         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01458         bool result;
01459         std::vector<std::string > temp1 ;
01460         std::vector<std::string > *v1 ;
01461         int argvi = 0;
01462         dXSARGS;
01463         
01464         if ((items < 1) || (items > 1)) {
01465             SWIG_croak("Usage: StrVector_empty(self);");
01466         }
01467         {
01468             if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
01469             SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
01470                 arg1 = v1;
01471             } else if (SvROK(ST(0))) {
01472                 AV *av = (AV *)SvRV(ST(0));
01473                 if (SvTYPE(av) != SVt_PVAV)
01474                 SWIG_croak("Type error in argument 1 of StrVector_empty. "
01475                 "Expected an array of ""std::string");
01476                 SV **tv;
01477                 I32 len = av_len(av) + 1;
01478                 std::string* obj;
01479                 for (int i=0; i<len; i++) {
01480                     tv = av_fetch(av, i, 0);
01481                     if (SvPOK(*tv)) {
01482                         temp1.push_back(SvPVX(*tv));
01483                     } else {
01484                         SWIG_croak("Type error in argument 1 of "
01485                         "StrVector_empty. "
01486                         "Expected an array of ""std::string");
01487                     }
01488                 }
01489                 arg1 = &temp1;
01490             } else {
01491                 SWIG_croak("Type error in argument 1 of StrVector_empty. "
01492                 "Expected an array of ""std::string");
01493             }
01494         }
01495         {
01496             try {
01497                 result = (bool)((std::vector<std::string > const *)arg1)->empty();
01498                 
01499             } catch (const char *msg) {
01500                 SWIG_exception(SWIG_RuntimeError, msg);
01501             }
01502         }
01503         ST(argvi) = sv_newmortal();
01504         sv_setiv(ST(argvi++), (IV) result);
01505         XSRETURN(argvi);
01506         fail:
01507         ;
01508     }
01509     croak(Nullch);
01510 }

XS _wrap_StrVector_size   ) 
 

Definition at line 1397 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_RuntimeError, and SWIGTYPE_p_std__vectorTstd__string_t.

01397                          {
01398     {
01399         std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
01400         unsigned int result;
01401         std::vector<std::string > temp1 ;
01402         std::vector<std::string > *v1 ;
01403         int argvi = 0;
01404         dXSARGS;
01405         
01406         if ((items < 1) || (items > 1)) {
01407             SWIG_croak("Usage: StrVector_size(self);");
01408         }
01409         {
01410             if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
01411             SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
01412                 arg1 = v1;
01413             } else if (SvROK(ST(0))) {
01414                 AV *av = (AV *)SvRV(ST(0));
01415                 if (SvTYPE(av) != SVt_PVAV)
01416                 SWIG_croak("Type error in argument 1 of StrVector_size. "
01417                 "Expected an array of ""std::string");
01418                 SV **tv;
01419                 I32 len = av_len(av) + 1;
01420                 std::string* obj;
01421                 for (int i=0; i<len; i++) {
01422                     tv = av_fetch(av, i, 0);
01423                     if (SvPOK(*tv)) {
01424                         temp1.push_back(SvPVX(*tv));
01425                     } else {
01426                         SWIG_croak("Type error in argument 1 of "
01427                         "StrVector_size. "
01428                         "Expected an array of ""std::string");
01429                     }
01430                 }
01431                 arg1 = &temp1;
01432             } else {
01433                 SWIG_croak("Type error in argument 1 of StrVector_size. "
01434                 "Expected an array of ""std::string");
01435             }
01436         }
01437         {
01438             try {
01439                 result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
01440                 
01441             } catch (const char *msg) {
01442                 SWIG_exception(SWIG_RuntimeError, msg);
01443             }
01444         }
01445         ST(argvi) = sv_newmortal();
01446         sv_setuv(ST(argvi++), (UV) result);
01447         XSRETURN(argvi);
01448         fail:
01449         ;
01450     }
01451     croak(Nullch);
01452 }

XS _wrap_new_StrVector   ) 
 

Definition at line 1326 of file HyperEstraier_wrap.cpp.

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

01326                         {
01327     dXSARGS;
01328     
01329     if (items == 0) {
01330         (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_1); return;
01331     }
01332     if (items == 1) {
01333         int _v;
01334         {
01335             _v = SvIOK(ST(0)) ? 1 : 0;
01336         }
01337         if (_v) {
01338             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_0); return;
01339         }
01340     }
01341     if (items == 1) {
01342         int _v;
01343         {
01344             {
01345                 /* wrapped vector? */
01346                 std::vector<std::string >* v;
01347                 if (SWIG_ConvertPtr(ST(0),(void **) &v, 
01348                 SWIGTYPE_p_std__vectorTstd__string_t,0) != -1) {
01349                     _v = 1;
01350                 } else if (SvROK(ST(0))) {
01351                     /* native sequence? */
01352                     AV *av = (AV *)SvRV(ST(0));
01353                     if (SvTYPE(av) == SVt_PVAV) {
01354                         SV **tv;
01355                         I32 len = av_len(av) + 1;
01356                         if (len == 0) {
01357                             /* an empty sequence can be of any type */
01358                             _v = 1;
01359                         } else {
01360                             /* check the first element only */
01361                             tv = av_fetch(av, 0, 0);
01362                             if (SvPOK(*tv))
01363                             _v = 1;
01364                             else
01365                             _v = 0;
01366                         }
01367                     }
01368                 } else {
01369                     _v = 0;
01370                 }
01371             }
01372         }
01373         if (_v) {
01374             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_3); return;
01375         }
01376     }
01377     if (items == 2) {
01378         int _v;
01379         {
01380             _v = SvIOK(ST(0)) ? 1 : 0;
01381         }
01382         if (_v) {
01383             {
01384                 _v = SvPOK(ST(1)) ? 1 : 0;
01385             }
01386             if (_v) {
01387                 (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_2); return;
01388             }
01389         }
01390     }
01391     
01392     croak("No matching function for overloaded 'new_StrVector'");
01393     XSRETURN(0);
01394 }

XS _wrap_new_StrVector__SWIG_3   ) 
 

Definition at line 1268 of file HyperEstraier_wrap.cpp.

References SWIG_ConvertPtr, SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTstd__string_t.

01268                                 {
01269     {
01270         std::vector<std::string > *arg1 = 0 ;
01271         std::vector<std::string > *result;
01272         std::vector<std::string > temp1 ;
01273         std::vector<std::string > *v1 ;
01274         int argvi = 0;
01275         dXSARGS;
01276         
01277         if ((items < 1) || (items > 1)) {
01278             SWIG_croak("Usage: new_StrVector(std::vector<std::string > const &);");
01279         }
01280         {
01281             if (SWIG_ConvertPtr(ST(0),(void **) &v1, 
01282             SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
01283                 arg1 = v1;
01284             } else if (SvROK(ST(0))) {
01285                 AV *av = (AV *)SvRV(ST(0));
01286                 if (SvTYPE(av) != SVt_PVAV)
01287                 SWIG_croak("Type error in argument 1 of new_StrVector. "
01288                 "Expected an array of ""std::string");
01289                 SV **tv;
01290                 I32 len = av_len(av) + 1;
01291                 std::string* obj;
01292                 for (int i=0; i<len; i++) {
01293                     tv = av_fetch(av, i, 0);
01294                     if (SvPOK(*tv)) {
01295                         temp1.push_back(SvPVX(*tv));
01296                     } else {
01297                         SWIG_croak("Type error in argument 1 of "
01298                         "new_StrVector. "
01299                         "Expected an array of ""std::string");
01300                     }
01301                 }
01302                 arg1 = &temp1;
01303             } else {
01304                 SWIG_croak("Type error in argument 1 of new_StrVector. "
01305                 "Expected an array of ""std::string");
01306             }
01307         }
01308         {
01309             try {
01310                 result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
01311                 
01312             } catch (const char *msg) {
01313                 SWIG_exception(SWIG_RuntimeError, msg);
01314             }
01315         }
01316         ST(argvi) = sv_newmortal();
01317         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
01318         XSRETURN(argvi);
01319         fail:
01320         ;
01321     }
01322     croak(Nullch);
01323 }

XS _wrap_new_StrVector__SWIG_2   ) 
 

Definition at line 1229 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTstd__string_t.

01229                                 {
01230     {
01231         unsigned int arg1 ;
01232         std::string arg2 ;
01233         std::vector<std::string > *result;
01234         int argvi = 0;
01235         dXSARGS;
01236         
01237         if ((items < 2) || (items > 2)) {
01238             SWIG_croak("Usage: new_StrVector(size,value);");
01239         }
01240         arg1 = (unsigned int) SvUV(ST(0));
01241         {
01242             STRLEN len;
01243             const char *ptr = SvPV(ST(1), len);
01244             if (!ptr) {
01245                 SWIG_croak("Undefined variable in argument 2 of new_StrVector.");
01246             } else {
01247                 arg2 = std::string(ptr, len);
01248             }
01249         }
01250         {
01251             try {
01252                 result = (std::vector<std::string > *)new std::vector<std::string >(arg1,arg2);
01253                 
01254             } catch (const char *msg) {
01255                 SWIG_exception(SWIG_RuntimeError, msg);
01256             }
01257         }
01258         ST(argvi) = sv_newmortal();
01259         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
01260         XSRETURN(argvi);
01261         fail:
01262         ;
01263     }
01264     croak(Nullch);
01265 }

XS _wrap_new_StrVector__SWIG_1   ) 
 

Definition at line 1202 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTstd__string_t.

01202                                 {
01203     {
01204         std::vector<std::string > *result;
01205         int argvi = 0;
01206         dXSARGS;
01207         
01208         if ((items < 0) || (items > 0)) {
01209             SWIG_croak("Usage: new_StrVector();");
01210         }
01211         {
01212             try {
01213                 result = (std::vector<std::string > *)new std::vector<std::string >();
01214                 
01215             } catch (const char *msg) {
01216                 SWIG_exception(SWIG_RuntimeError, msg);
01217             }
01218         }
01219         ST(argvi) = sv_newmortal();
01220         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
01221         XSRETURN(argvi);
01222         fail:
01223         ;
01224     }
01225     croak(Nullch);
01226 }

XS _wrap_new_StrVector__SWIG_0   ) 
 

Definition at line 1173 of file HyperEstraier_wrap.cpp.

References SWIG_croak, SWIG_exception, SWIG_MakePtr, SWIG_OWNER, SWIG_RuntimeError, SWIG_SHADOW, and SWIGTYPE_p_std__vectorTstd__string_t.

01173                                 {
01174     {
01175         unsigned int arg1 ;
01176         std::vector<std::string > *result;
01177         int argvi = 0;
01178         dXSARGS;
01179         
01180         if ((items < 1) || (items > 1)) {
01181             SWIG_croak("Usage: new_StrVector(size);");
01182         }
01183         arg1 = (unsigned int) SvUV(ST(0));
01184         {
01185             try {
01186                 result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
01187                 
01188             } catch (const char *msg) {
01189                 SWIG_exception(SWIG_RuntimeError, msg);
01190             }
01191         }
01192         ST(argvi) = sv_newmortal();
01193         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
01194         XSRETURN(argvi);
01195         fail:
01196         ;
01197     }
01198     croak(Nullch);
01199 }

typedef XS SwigPerlWrapper   ) 
 


Variable Documentation

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 4400 of file HyperEstraier_wrap.cpp.

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 4402 of file HyperEstraier_wrap.cpp.

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

Definition at line 4399 of file HyperEstraier_wrap.cpp.

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

Definition at line 4401 of file HyperEstraier_wrap.cpp.

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

Definition at line 4407 of file HyperEstraier_wrap.cpp.

swig_type_info _swigt__p_size_t[] = {{"_p_size_t", 0, "size_t *", 0, 0, 0, 0},{"_p_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 4408 of file HyperEstraier_wrap.cpp.

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

Definition at line 4404 of file HyperEstraier_wrap.cpp.

swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0, 0, 0, 0},{"_p_std__string", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}} [static]
 

Definition at line 4406 of file HyperEstraier_wrap.cpp.

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

Definition at line 4405 of file HyperEstraier_wrap.cpp.

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

Definition at line 4403 of file HyperEstraier_wrap.cpp.

swig_command_info swig_commands[] [static]
 

Definition at line 4463 of file HyperEstraier_wrap.cpp.

swig_constant_info swig_constants[] [static]
 

Initial value:

 {
{ SWIG_INT,     (char *) SWIG_prefix "Condition_SURE", (long) estraier::Condition::SURE, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Condition_USUAL", (long) estraier::Condition::USUAL, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Condition_FAST", (long) estraier::Condition::FAST, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Condition_AGITO", (long) estraier::Condition::AGITO, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Condition_NOIDF", (long) estraier::Condition::NOIDF, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Condition_SIMPLE", (long) estraier::Condition::SIMPLE, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRNOERR", (long) estraier::Database::ERRNOERR, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRINVAL", (long) estraier::Database::ERRINVAL, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRACCES", (long) estraier::Database::ERRACCES, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRLOCK", (long) estraier::Database::ERRLOCK, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRDB", (long) estraier::Database::ERRDB, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRIO", (long) estraier::Database::ERRIO, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRNOITEM", (long) estraier::Database::ERRNOITEM, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ERRMISC", (long) estraier::Database::ERRMISC, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBREADER", (long) estraier::Database::DBREADER, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBWRITER", (long) estraier::Database::DBWRITER, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBCREAT", (long) estraier::Database::DBCREAT, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBTRUNC", (long) estraier::Database::DBTRUNC, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBNOLCK", (long) estraier::Database::DBNOLCK, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBLCKNB", (long) estraier::Database::DBLCKNB, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_DBPERFNG", (long) estraier::Database::DBPERFNG, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_PDCLEAN", (long) estraier::Database::PDCLEAN, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_ODCLEAN", (long) estraier::Database::ODCLEAN, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_OPTNOPURGE", (long) estraier::Database::OPTNOPURGE, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_OPTNODBOPT", (long) estraier::Database::OPTNODBOPT, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_GDNOATTR", (long) estraier::Database::GDNOATTR, 0, 0, 0},
{ SWIG_INT,     (char *) SWIG_prefix "Database_GDNOTEXT", (long) estraier::Database::GDNOTEXT, 0, 0, 0},
{0,0,0,0,0,0}
}

Definition at line 4427 of file HyperEstraier_wrap.cpp.

Referenced by XS().

swig_type_info* swig_type_list = 0 [static]
 

Definition at line 467 of file HyperEstraier_wrap.cpp.

swig_type_info** swig_type_list_handle = &swig_type_list [static]
 

Definition at line 468 of file HyperEstraier_wrap.cpp.

Referenced by SWIG_Perl_SetTypeListHandle(), SWIG_Ruby_InitRuntime(), and XS().

swig_type_info* swig_types[11] [static]
 

Definition at line 1014 of file HyperEstraier_wrap.cpp.

swig_type_info* swig_types_initial[] [static]
 

Initial value:

Definition at line 4410 of file HyperEstraier_wrap.cpp.

Referenced by XS().

swig_variable_info swig_variables[] [static]
 

Initial value:

 {
{0,0,0,0}
}

Definition at line 4460 of file HyperEstraier_wrap.cpp.


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