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

HyperEstraier_wrap.cpp

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 1.3.24
00004  * 
00005  * This file is not intended to be easily readable and contains a number of 
00006  * coding conventions designed to improve portability and efficiency. Do not make
00007  * changes to this file unless you know what you are doing--modify the SWIG 
00008  * interface file instead. 
00009  * ----------------------------------------------------------------------------- */
00010 
00011 
00012 #ifdef __cplusplus
00013 template<class T> class SwigValueWrapper {
00014     T *tt;
00015 public:
00016     SwigValueWrapper() : tt(0) { }
00017     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
00018     SwigValueWrapper(const T& t) : tt(new T(t)) { }
00019     ~SwigValueWrapper() { delete tt; } 
00020     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
00021     operator T&() const { return *tt; }
00022     T *operator&() { return tt; }
00023 private:
00024     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
00025 };
00026 #endif
00027 
00028 
00029 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
00030 #  if defined(__SUNPRO_CC) 
00031 #    define SWIG_TEMPLATE_DISAMBIGUATOR template
00032 #  else
00033 #    define SWIG_TEMPLATE_DISAMBIGUATOR 
00034 #  endif
00035 #endif
00036 
00037 /***********************************************************************
00038  * swigrun.swg
00039  *
00040  *     This file contains generic CAPI SWIG runtime support for pointer
00041  *     type checking.
00042  *
00043  ************************************************************************/
00044 
00045 /* This should only be incremented when either the layout of swig_type_info changes,
00046    or for whatever reason, the runtime changes incompatibly */
00047 #define SWIG_RUNTIME_VERSION "1"
00048 
00049 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
00050 #ifdef SWIG_TYPE_TABLE
00051 #define SWIG_QUOTE_STRING(x) #x
00052 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00053 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00054 #else
00055 #define SWIG_TYPE_TABLE_NAME
00056 #endif
00057 
00058 #include <string.h>
00059 
00060 #ifndef SWIGINLINE
00061 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00062 #  define SWIGINLINE inline
00063 #else
00064 #  define SWIGINLINE
00065 #endif
00066 #endif
00067 
00068 /*
00069   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00070   creating a static or dynamic library from the swig runtime code.
00071   In 99.9% of the cases, swig just needs to declare them as 'static'.
00072   
00073   But only do this if is strictly necessary, ie, if you have problems
00074   with your compiler or so.
00075 */
00076 #ifndef SWIGRUNTIME
00077 #define SWIGRUNTIME static
00078 #endif
00079 #ifndef SWIGRUNTIMEINLINE
00080 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00081 #endif
00082 
00083 #ifdef __cplusplus
00084 extern "C" {
00085 #endif
00086 
00087 typedef void *(*swig_converter_func)(void *);
00088 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00089 
00090 typedef struct swig_type_info {
00091   const char             *name;
00092   swig_converter_func     converter;
00093   const char             *str;
00094   void                   *clientdata;
00095   swig_dycast_func        dcast;
00096   struct swig_type_info  *next;
00097   struct swig_type_info  *prev;
00098 } swig_type_info;
00099 
00100 /* 
00101   Compare two type names skipping the space characters, therefore
00102   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00103 
00104   Return 0 when the two name types are equivalent, as in
00105   strncmp, but skipping ' '.
00106 */
00107 SWIGRUNTIME int
00108 SWIG_TypeNameComp(const char *f1, const char *l1,
00109           const char *f2, const char *l2) {
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 }
00117 
00118 /*
00119   Check type equivalence in a name list like <name1>|<name2>|...
00120 */
00121 SWIGRUNTIME int
00122 SWIG_TypeEquiv(const char *nb, const char *tb) {
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 }
00135 
00136 /*
00137   Register a type mapping with the type-checking
00138 */
00139 SWIGRUNTIME swig_type_info *
00140 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
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 }
00186 
00187 /*
00188   Check the typename
00189 */
00190 SWIGRUNTIME swig_type_info *
00191 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
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 }
00214 
00215 /*
00216   Cast a pointer up an inheritance hierarchy
00217 */
00218 SWIGRUNTIMEINLINE void *
00219 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
00220   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
00221 }
00222 
00223 /* 
00224    Dynamic pointer casting. Down an inheritance hierarchy
00225 */
00226 SWIGRUNTIME swig_type_info *
00227 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
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 }
00236 
00237 /*
00238   Return the name associated with this type
00239 */
00240 SWIGRUNTIMEINLINE const char *
00241 SWIG_TypeName(const swig_type_info *ty) {
00242   return ty->name;
00243 }
00244 
00245 /*
00246   Return the pretty name associated with this type,
00247   that is an unmangled type name in a form presentable to the user.
00248 */
00249 SWIGRUNTIME const char *
00250 SWIG_TypePrettyName(const swig_type_info *type) {
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 }
00265 
00266 /*
00267   Search for a swig_type_info structure
00268 */
00269 SWIGRUNTIME swig_type_info *
00270 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
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 }
00279 
00280 /* 
00281    Set the clientdata field for a type
00282 */
00283 SWIGRUNTIME void
00284 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
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 }
00302 
00303 /* 
00304    Pack binary data into a string
00305 */
00306 SWIGRUNTIME char *
00307 SWIG_PackData(char *c, void *ptr, size_t sz) {
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 }
00319 
00320 /* 
00321    Unpack binary data from a string
00322 */
00323 SWIGRUNTIME const char *
00324 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
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 }
00347 
00348 /*
00349   This function will propagate the clientdata field of type to any new
00350   swig_type_info structures that have been added into the list of
00351   equivalent types.  It is like calling SWIG_TypeClientData(type,
00352   clientdata) a second time.
00353 */
00354 SWIGRUNTIME void
00355 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
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 }
00371 
00372 /* 
00373    Pack 'void *' into a string buffer.
00374 */
00375 SWIGRUNTIME char *
00376 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
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 }
00385 
00386 SWIGRUNTIME const char *
00387 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
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 }
00398 
00399 SWIGRUNTIME char *
00400 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
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 }
00413 
00414 SWIGRUNTIME const char *
00415 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
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 }
00426 
00427 #ifdef __cplusplus
00428 }
00429 #endif
00430 
00431 /***********************************************************************
00432  * common.swg
00433  *
00434  *     This file contains generic SWIG runtime support for pointer
00435  *     type checking as well as a few commonly used macros to control
00436  *     external linkage.
00437  *
00438  * Author : David Beazley (beazley@cs.uchicago.edu)
00439  *
00440  * Copyright (c) 1999-2000, The University of Chicago
00441  * 
00442  * This file may be freely redistributed without license or fee provided
00443  * this copyright message remains intact.
00444  ************************************************************************/
00445 
00446 
00447 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00448 #  if !defined(STATIC_LINKED)
00449 #    define SWIGEXPORT(a) __declspec(dllexport) a
00450 #  else
00451 #    define SWIGEXPORT(a) a
00452 #  endif
00453 #else
00454 #  define SWIGEXPORT(a) a
00455 #endif
00456 
00457 #ifdef __cplusplus
00458 extern "C" {
00459 #endif
00460 
00461 
00462 /*************************************************************************/
00463 
00464 
00465 /* The static type info list */
00466 
00467 static swig_type_info *swig_type_list = 0;
00468 static swig_type_info **swig_type_list_handle = &swig_type_list;
00469   
00470 
00471 /* Register a type mapping with the type-checking */
00472 static swig_type_info *
00473 SWIG_TypeRegister(swig_type_info *ti) {
00474   return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
00475 }
00476 
00477 /* Search for a swig_type_info structure */
00478 static swig_type_info *
00479 SWIG_TypeQuery(const char *name) {
00480   return SWIG_TypeQueryTL(*swig_type_list_handle, name);
00481 }
00482 
00483 /* Set the clientdata field for a type */
00484 static void
00485 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00486   SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
00487 }
00488 
00489 /* This function will propagate the clientdata field of type to
00490 * any new swig_type_info structures that have been added into the list
00491 * of equivalent types.  It is like calling
00492 * SWIG_TypeClientData(type, clientdata) a second time.
00493 */
00494 static void
00495 SWIG_PropagateClientData(swig_type_info *type) {
00496   SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
00497 }
00498 
00499 #ifdef __cplusplus
00500 }
00501 #endif
00502 
00503 /* ---------------------------------------------------------------------- -*- c -*-
00504  * perl5.swg
00505  *
00506  * Perl5 runtime library
00507  * $Header: /cvsroot/swig/SWIG/Lib/perl5/perlrun.swg,v 1.20 2004/11/29 23:13:57 wuzzeb Exp $
00508  * ----------------------------------------------------------------------------- */
00509 
00510 #define SWIGPERL
00511 #define SWIGPERL5
00512 #ifdef __cplusplus
00513 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
00514 #include <math.h>
00515 #include <stdlib.h>
00516 extern "C" {
00517 #endif
00518 #include "EXTERN.h"
00519 #include "perl.h"
00520 #include "XSUB.h"
00521 
00522 /* Get rid of free and malloc defined by perl */
00523 #undef free
00524 #undef malloc
00525 
00526 #ifndef pTHX_
00527 #define pTHX_
00528 #endif
00529 
00530 #include <string.h>
00531 #ifdef __cplusplus
00532 }
00533 #endif
00534 
00535 /* Macro to call an XS function */
00536 
00537 #ifdef PERL_OBJECT 
00538 #  define SWIG_CALLXS(_name) _name(cv,pPerl) 
00539 #else 
00540 #  ifndef MULTIPLICITY 
00541 #    define SWIG_CALLXS(_name) _name(cv) 
00542 #  else 
00543 #    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv) 
00544 #  endif 
00545 #endif 
00546 
00547 /* Contract support */
00548 
00549 #define SWIG_contract_assert(expr,msg) if (!(expr)) { SWIG_croak(msg); } else
00550 
00551 /* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
00552 
00553 #ifdef PERL_OBJECT
00554 #define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
00555 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
00556 
00557 #ifdef __cplusplus
00558 extern "C" {
00559 #endif
00560 typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
00561 #ifdef __cplusplus
00562 }
00563 #endif
00564 
00565 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
00566 #define SWIGCLASS_STATIC
00567 #else
00568 #define MAGIC_PPERL
00569 #define SWIGCLASS_STATIC static
00570 #ifndef MULTIPLICITY
00571 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
00572 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
00573 
00574 #ifdef __cplusplus
00575 extern "C" {
00576 #endif
00577 typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
00578 #ifdef __cplusplus
00579 }
00580 #endif
00581 
00582 
00583 #else
00584 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
00585 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
00586 #ifdef __cplusplus
00587 extern "C" {
00588 #endif
00589 typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
00590 #ifdef __cplusplus
00591 }
00592 #endif
00593 
00594 #endif
00595 #endif
00596 
00597 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
00598 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
00599 #endif
00600 
00601 /* Modifications for newer Perl 5.005 releases */
00602 
00603 #if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
00604 #  ifndef PL_sv_yes
00605 #    define PL_sv_yes sv_yes
00606 #  endif
00607 #  ifndef PL_sv_undef
00608 #    define PL_sv_undef sv_undef
00609 #  endif
00610 #  ifndef PL_na
00611 #    define PL_na na
00612 #  endif
00613 #endif
00614 
00615 #include <stdlib.h>
00616 
00617 #ifdef __cplusplus
00618 extern "C" {
00619 #endif
00620 
00621 #define SWIG_OWNER 1
00622 #define SWIG_SHADOW 2
00623 
00624 /* Common SWIG API */
00625 
00626 #ifdef PERL_OBJECT
00627 #  define SWIG_ConvertPtr(obj, pp, type, flags) \
00628      SWIG_Perl_ConvertPtr(pPerl, obj, pp, type, flags)
00629 #  define SWIG_NewPointerObj(p, type, flags) \
00630      SWIG_Perl_NewPointerObj(pPerl, p, type, flags)
00631 #  define SWIG_MakePackedObj(sv, p, s, type)    \
00632      SWIG_Perl_MakePackedObj(pPerl, sv, p, s, type)
00633 #  define SWIG_ConvertPacked(obj, p, s, type, flags) \
00634      SWIG_Perl_ConvertPacked(pPerl, obj, p, s, type, flags)
00635 
00636 #else
00637 #  define SWIG_ConvertPtr(obj, pp, type, flags) \
00638      SWIG_Perl_ConvertPtr(obj, pp, type, flags)
00639 #  define SWIG_NewPointerObj(p, type, flags) \
00640      SWIG_Perl_NewPointerObj(p, type, flags)
00641 #  define SWIG_MakePackedObj(sv, p, s, type)    \
00642      SWIG_Perl_MakePackedObj(sv, p, s, type )
00643 #  define SWIG_ConvertPacked(obj, p, s, type, flags) \
00644      SWIG_Perl_ConvertPacked(obj, p, s, type, flags)
00645 #endif
00646 
00647 /* Perl-specific API */
00648 #ifdef PERL_OBJECT
00649 #  define SWIG_MakePtr(sv, ptr, type, flags) \
00650      SWIG_Perl_MakePtr(pPerl, sv, ptr, type, flags)
00651 #  define SWIG_SetError(str) \
00652      SWIG_Perl_SetError(pPerl, str)
00653 #else
00654 #  define SWIG_MakePtr(sv, ptr, type, flags) \
00655      SWIG_Perl_MakePtr(sv, ptr, type, flags)
00656 #  define SWIG_SetError(str) \
00657      SWIG_Perl_SetError(str)
00658 #  define SWIG_SetErrorSV(str) \
00659      SWIG_Perl_SetErrorSV(str)
00660 #endif
00661 
00662 #define SWIG_SetErrorf SWIG_Perl_SetErrorf
00663 
00664 
00665 #ifdef PERL_OBJECT
00666 #  define SWIG_MAYBE_PERL_OBJECT CPerlObj *pPerl,
00667 #else
00668 #  define SWIG_MAYBE_PERL_OBJECT
00669 #endif
00670 
00671 static swig_type_info **
00672 SWIG_Perl_GetTypeListHandle() {
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 }
00686 
00687 /*
00688   Search for a swig_type_info structure
00689  */
00690 SWIGRUNTIMEINLINE swig_type_info *
00691 SWIG_Perl_GetTypeList() {
00692   swig_type_info **tlh = SWIG_Perl_GetTypeListHandle();
00693   return tlh ? *tlh : (swig_type_info*)0;
00694 }
00695 
00696 #define SWIG_Runtime_GetTypeList SWIG_Perl_GetTypeList 
00697 
00698 static swig_type_info *
00699 SWIG_Perl_TypeCheckRV(SWIG_MAYBE_PERL_OBJECT SV *rv, swig_type_info *ty) {
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 }
00722 
00723 /* Function for getting a pointer value */
00724 
00725 static int
00726 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
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 }
00786 
00787 static void
00788 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
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 }
00815 
00816 static SWIGINLINE SV *
00817 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
00818   SV *result = sv_newmortal();
00819   SWIG_MakePtr(result, ptr, t, flags);
00820   return result;
00821 }
00822 
00823 static void
00824   SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
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 }
00833 
00834 /* Convert a packed value value */
00835 static int
00836 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
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 }
00852 
00853 static SWIGINLINE void
00854 SWIG_Perl_SetError(SWIG_MAYBE_PERL_OBJECT const char *error) {
00855   if (error) sv_setpv(perl_get_sv("@", TRUE), error);
00856 }
00857 
00858 static SWIGINLINE void
00859 SWIG_Perl_SetErrorSV(SWIG_MAYBE_PERL_OBJECT SV *error) {
00860   if (error) sv_setsv(perl_get_sv("@", TRUE), error);
00861 }
00862 
00863 static void
00864 SWIG_Perl_SetErrorf(const char *fmt, ...) {
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 }
00870 
00871 /* Macros for low-level exception handling */
00872 #define SWIG_fail       goto fail
00873 #define SWIG_croak(x)   { SWIG_SetError(x); goto fail; }
00874 #define SWIG_croakSV(x) { SWIG_SetErrorSV(x); goto fail; }
00875 /* most preprocessors do not support vararg macros :-( */
00876 /* #define SWIG_croakf(x...) { SWIG_SetErrorf(x); goto fail; } */
00877 
00878 
00879 typedef XS(SwigPerlWrapper);
00880 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
00881 
00882 /* Structure for command table */
00883 typedef struct {
00884   const char         *name;
00885   SwigPerlWrapperPtr  wrapper;
00886 } swig_command_info;
00887 
00888 /* Information for constant table */
00889 
00890 #define SWIG_INT     1
00891 #define SWIG_FLOAT   2
00892 #define SWIG_STRING  3
00893 #define SWIG_POINTER 4
00894 #define SWIG_BINARY  5
00895 
00896 /* Constant information structure */
00897 typedef struct swig_constant_info {
00898     int              type;
00899     const char      *name;
00900     long             lvalue;
00901     double           dvalue;
00902     void            *pvalue;
00903     swig_type_info **ptype;
00904 } swig_constant_info;
00905 
00906 #ifdef __cplusplus
00907 }
00908 #endif
00909 
00910 /* Structure for variable table */
00911 typedef struct {
00912   const char   *name;
00913   SwigMagicFunc   set;
00914   SwigMagicFunc   get;
00915   swig_type_info  **type;
00916 } swig_variable_info;
00917 
00918 /* Magic variable code */
00919 #ifndef PERL_OBJECT
00920 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
00921   #ifndef MULTIPLICITY
00922      static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
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 }
00940 
00941 
00942 
00943 
00944 
00945 
00946 #ifdef do_open
00947   #undef do_open
00948 #endif
00949 #ifdef do_close
00950   #undef do_close
00951 #endif
00952 #ifdef scalar
00953   #undef scalar
00954 #endif
00955 #ifdef list
00956   #undef list
00957 #endif
00958 #ifdef apply
00959   #undef apply
00960 #endif
00961 #ifdef convert
00962   #undef convert
00963 #endif
00964 #ifdef Error
00965   #undef Error
00966 #endif
00967 #ifdef form
00968   #undef form
00969 #endif
00970 #ifdef vform
00971   #undef vform
00972 #endif
00973 #ifdef LABEL
00974   #undef LABEL
00975 #endif
00976 #ifdef METHOD
00977   #undef METHOD
00978 #endif
00979 #ifdef Move
00980   #undef Move
00981 #endif
00982 #ifdef yylex
00983   #undef yylex
00984 #endif
00985 #ifdef yyparse
00986   #undef yyparse
00987 #endif
00988 #ifdef yyerror
00989   #undef yyerror
00990 #endif
00991 #ifdef invert
00992   #undef invert
00993 #endif
00994 #ifdef ref
00995   #undef ref
00996 #endif
00997 #ifdef ENTER
00998   #undef ENTER
00999 #endif
01000 
01001 
01002 /* -------- TYPES TABLE (BEGIN) -------- */
01003 
01004 #define  SWIGTYPE_p_estraier__Condition swig_types[0] 
01005 #define  SWIGTYPE_p_ESTCOND swig_types[1] 
01006 #define  SWIGTYPE_p_estraier__Database swig_types[2] 
01007 #define  SWIGTYPE_p_ESTDOC swig_types[3] 
01008 #define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[4] 
01009 #define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[5] 
01010 #define  SWIGTYPE_p_std__vectorTint_t swig_types[6] 
01011 #define  SWIGTYPE_p_std__string swig_types[7] 
01012 #define  SWIGTYPE_p_estraier__Document swig_types[8] 
01013 #define  SWIGTYPE_p_size_t swig_types[9] 
01014 static swig_type_info *swig_types[11];
01015 
01016 /* -------- TYPES TABLE (END) -------- */
01017 
01018 #define SWIG_init    boot_HyperEstraier
01019 
01020 #define SWIG_name   "HyperEstraierc::boot_HyperEstraier"
01021 #define SWIG_prefix "HyperEstraierc::"
01022 
01023 #ifdef __cplusplus
01024 extern "C"
01025 #endif
01026 #ifndef PERL_OBJECT
01027 #ifndef MULTIPLICITY
01028 SWIGEXPORT(void) SWIG_init (CV* cv);
01029 #else
01030 SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
01031 #endif
01032 #else
01033 SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
01034 #endif
01035 
01036 
01037 #define  SWIG_MemoryError    1
01038 #define  SWIG_IOError        2
01039 #define  SWIG_RuntimeError   3
01040 #define  SWIG_IndexError     4
01041 #define  SWIG_TypeError      5
01042 #define  SWIG_DivisionByZero 6
01043 #define  SWIG_OverflowError  7
01044 #define  SWIG_SyntaxError    8
01045 #define  SWIG_ValueError     9
01046 #define  SWIG_SystemError   10
01047 #define  SWIG_UnknownError  99
01048 
01049 
01050 #define SWIG_exception(a,b)   SWIG_croak(b)
01051 
01052 
01053 #include <stdexcept>
01054 
01055 
01056 #include <string>
01057 
01058 double SwigSvToNumber(SV* sv) {
01059     return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
01060 }
01061 std::string SwigSvToString(SV* sv) {
01062     STRLEN len;
01063     return SvPV(sv,len);
01064 }
01065 void SwigSvFromString(SV* sv, const std::string& s) {
01066     sv_setpv(sv,s.c_str());
01067 }
01068 
01069 
01070 #include <string>
01071 
01072 
01073 #include <vector>
01074 #include <algorithm>
01075 #include <stdexcept>
01076 
01077 
01078 #include <map>
01079 #include <algorithm>
01080 #include <stdexcept>
01081 
01082 
01083 #include <utility>
01084 
01085 static std::string std_vector_Sl_std_string_Sg__pop(std::vector<std::string > *self){
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             }
01092 static std::string std_vector_Sl_std_string_Sg__get(std::vector<std::string > *self,int i){
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             }
01099 static void std_vector_Sl_std_string_Sg__set(std::vector<std::string > *self,int i,std::string x){
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             }
01106 static int std_vector_Sl_int_Sg__pop(std::vector<int > *self){
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             }
01113 static int std_vector_Sl_int_Sg__get(std::vector<int > *self,int i){
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             }
01120 static void std_vector_Sl_int_Sg__set(std::vector<int > *self,int i,int x){
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             }
01127 static std::string &std_map_Sl_std_string_Sc_std_string_Sg__get(std::map<std::string,std::string > *self,std::string const &key){
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             }
01134 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){
01135                 (*self)[key] = x;
01136             }
01137 static void std_map_Sl_std_string_Sc_std_string_Sg__del(std::map<std::string,std::string > *self,std::string const &key){
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             }
01144 static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map<std::string,std::string > *self,std::string const &key){
01145                 std::map<std::string,std::string >::iterator i = self->find(key);
01146                 return i != self->end();
01147             }
01148 
01149 #include "HyperEstraierWrapper.cpp"
01150 
01151 #ifdef PERL_OBJECT
01152 #define MAGIC_CLASS _wrap_HyperEstraier_var::
01153 class _wrap_HyperEstraier_var : public CPerlObj {
01154 public:
01155 #else
01156 #define MAGIC_CLASS
01157 #endif
01158 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
01159     MAGIC_PPERL
01160     sv = sv; mg = mg;
01161     croak("Value is read-only.");
01162     return 0;
01163 }
01164 
01165 
01166 #ifdef PERL_OBJECT
01167 };
01168 #endif
01169 
01170 #ifdef __cplusplus
01171 extern "C" {
01172 #endif
01173 XS(_wrap_new_StrVector__SWIG_0) {
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 }
01200 
01201 
01202 XS(_wrap_new_StrVector__SWIG_1) {
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 }
01227 
01228 
01229 XS(_wrap_new_StrVector__SWIG_2) {
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 }
01266 
01267 
01268 XS(_wrap_new_StrVector__SWIG_3) {
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 }
01324 
01325 
01326 XS(_wrap_new_StrVector) {
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 }
01395 
01396 
01397 XS(_wrap_StrVector_size) {
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 }
01453 
01454 
01455 XS(_wrap_StrVector_empty) {
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 }
01511 
01512 
01513 XS(_wrap_StrVector_clear) {
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 }
01542 
01543 
01544 XS(_wrap_StrVector_push) {
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 }
01583 
01584 
01585 XS(_wrap_StrVector_pop) {
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 }
01620 
01621 
01622 XS(_wrap_StrVector_get) {
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 }
01659 
01660 
01661 XS(_wrap_StrVector_set) {
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 }
01702 
01703 
01704 XS(_wrap_delete_StrVector) {
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 }
01733 
01734 
01735 XS(_wrap_new_IntVector__SWIG_0) {
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 }
01762 
01763 
01764 XS(_wrap_new_IntVector__SWIG_1) {
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 }
01789 
01790 
01791 XS(_wrap_new_IntVector__SWIG_2) {
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 }
01820 
01821 
01822 XS(_wrap_new_IntVector__SWIG_3) {
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 }
01878 
01879 
01880 XS(_wrap_new_IntVector) {
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 }
01949 
01950 
01951 XS(_wrap_IntVector_size) {
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 }
02007 
02008 
02009 XS(_wrap_IntVector_empty) {
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 }
02065 
02066 
02067 XS(_wrap_IntVector_clear) {
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 }
02096 
02097 
02098 XS(_wrap_IntVector_push) {
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 }
02129 
02130 
02131 XS(_wrap_IntVector_pop) {
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 }
02162 
02163 
02164 XS(_wrap_IntVector_get) {
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 }
02197 
02198 
02199 XS(_wrap_IntVector_set) {
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 }
02232 
02233 
02234 XS(_wrap_delete_IntVector) {
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 }
02263 
02264 
02265 XS(_wrap_new_StrStrMap__SWIG_0) {
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 }
02290 
02291 
02292 XS(_wrap_new_StrStrMap__SWIG_1) {
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 }
02323 
02324 
02325 XS(_wrap_new_StrStrMap) {
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 }
02349 
02350 
02351 XS(_wrap_StrStrMap_size) {
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 }
02382 
02383 
02384 XS(_wrap_StrStrMap_empty) {
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 }
02415 
02416 
02417 XS(_wrap_StrStrMap_clear) {
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 }
02446 
02447 
02448 XS(_wrap_StrStrMap_get) {
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 }
02494 
02495 
02496 XS(_wrap_StrStrMap_set) {
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 }
02549 
02550 
02551 XS(_wrap_StrStrMap_del) {
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 }
02592 
02593 
02594 XS(_wrap_StrStrMap_has_key) {
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 }
02637 
02638 
02639 XS(_wrap_delete_StrStrMap) {
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 }
02668 
02669 
02670 XS(_wrap_Condition_cond_set) {
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 }
02699 
02700 
02701 XS(_wrap_Condition_cond_get) {
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 }
02726 
02727 
02728 XS(_wrap_new_Condition) {
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 }
02753 
02754 
02755 XS(_wrap_delete_Condition) {
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 }
02784 
02785 
02786 XS(_wrap_Condition_set_phrase) {
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 }
02818 
02819 
02820 XS(_wrap_Condition_add_attr) {
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 }
02852 
02853 
02854 XS(_wrap_Condition_set_order) {
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 }
02886 
02887 
02888 XS(_wrap_Condition_set_max) {
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 }
02919 
02920 
02921 XS(_wrap_Condition_set_options) {
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 }
02952 
02953 
02954 XS(_wrap_Document_doc_set) {
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 }
02983 
02984 
02985 XS(_wrap_Document_doc_get) {
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 }
03010 
03011 
03012 XS(_wrap_new_Document__SWIG_0) {
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 }
03037 
03038 
03039 XS(_wrap_new_Document__SWIG_1) {
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 }
03067 
03068 
03069 XS(_wrap_new_Document__SWIG_2) {
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 }
03100 
03101 
03102 XS(_wrap_new_Document) {
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 }
03135 
03136 
03137 XS(_wrap_delete_Document) {
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 }
03166 
03167 
03168 XS(_wrap_Document_add_attr) {
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 }
03203 
03204 
03205 XS(_wrap_Document_add_text) {
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 }
03237 
03238 
03239 XS(_wrap_Document_add_hidden_text) {
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 }
03271 
03272 
03273 XS(_wrap_Document_id) {
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 }
03304 
03305 
03306 XS(_wrap_Document_attr_names) {
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 }
03337 
03338 
03339 XS(_wrap_Document_attr) {
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 }
03377 
03378 
03379 XS(_wrap_Document_cat_texts) {
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 }
03414 
03415 
03416 XS(_wrap_Document_texts) {
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 }
03447 
03448 
03449 XS(_wrap_Document_dump_draft) {
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 }
03484 
03485 
03486 XS(_wrap_Document_make_snippet) {
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 }
03555 
03556 
03557 XS(_wrap_new_Database) {
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 }
03582 
03583 
03584 XS(_wrap_delete_Database) {
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 }
03613 
03614 
03615 XS(_wrap_Database_open) {
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 }
03651 
03652 
03653 XS(_wrap_Database_close) {
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 }
03684 
03685 
03686 XS(_wrap_Database_put_doc) {
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 }
03725 
03726 
03727 XS(_wrap_Database_search) {
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 }
03766 
03767 
03768 XS(_wrap_Database_err_msg) {
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 }
03799 
03800 
03801 XS(_wrap_Database_error) {
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 }
03832 
03833 
03834 XS(_wrap_Database_fatal) {
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 }
03865 
03866 
03867 XS(_wrap_Database_flush) {
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 }
03900 
03901 
03902 XS(_wrap_Database_sync) {
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 }
03933 
03934 
03935 XS(_wrap_Database_optimize) {
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 }
03968 
03969 
03970 XS(_wrap_Database_out_doc) {
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 }
04005 
04006 
04007 XS(_wrap_Database_get_doc) {
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 }
04042 
04043 
04044 XS(_wrap_Database_uri_to_id) {
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 }
04078 
04079 
04080 XS(_wrap_Database_etch_doc) {
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 }
04119 
04120 
04121 XS(_wrap_Database_iter_init) {
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 }
04152 
04153 
04154 XS(_wrap_Database_iter_next) {
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 }
04185 
04186 
04187 XS(_wrap_Database_name) {
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 }
04222 
04223 
04224 XS(_wrap_Database_doc_num) {
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 }
04255 
04256 
04257 XS(_wrap_Database_word_num) {
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 }
04288 
04289 
04290 XS(_wrap_Database_size) {
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 }
04321 
04322 
04323 XS(_wrap_Database_set_cache_size) {
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 }
04358 
04359 
04360 XS(_wrap_Database_set_special_cache) {
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 }
04394 
04395 
04396 
04397 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
04398 
04399 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}};
04400 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}};
04401 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}};
04402 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}};
04403 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}};
04404 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}};
04405 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}};
04406 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}};
04407 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}};
04408 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}};
04409 
04410 static swig_type_info *swig_types_initial[] = {
04411 _swigt__p_estraier__Condition, 
04412 _swigt__p_ESTCOND, 
04413 _swigt__p_estraier__Database, 
04414 _swigt__p_ESTDOC, 
04415 _swigt__p_std__vectorTstd__string_t, 
04416 _swigt__p_std__mapTstd__string_std__string_t, 
04417 _swigt__p_std__vectorTint_t, 
04418 _swigt__p_std__string, 
04419 _swigt__p_estraier__Document, 
04420 _swigt__p_size_t, 
04421 0
04422 };
04423 
04424 
04425 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
04426 
04427 static swig_constant_info swig_constants[] = {
04428 { SWIG_INT,     (char *) SWIG_prefix "Condition_SURE", (long) estraier::Condition::SURE, 0, 0, 0},
04429 { SWIG_INT,     (char *) SWIG_prefix "Condition_USUAL", (long) estraier::Condition::USUAL, 0, 0, 0},
04430 { SWIG_INT,     (char *) SWIG_prefix "Condition_FAST", (long) estraier::Condition::FAST, 0, 0, 0},
04431 { SWIG_INT,     (char *) SWIG_prefix "Condition_AGITO", (long) estraier::Condition::AGITO, 0, 0, 0},
04432 { SWIG_INT,     (char *) SWIG_prefix "Condition_NOIDF", (long) estraier::Condition::NOIDF, 0, 0, 0},
04433 { SWIG_INT,     (char *) SWIG_prefix "Condition_SIMPLE", (long) estraier::Condition::SIMPLE, 0, 0, 0},
04434 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRNOERR", (long) estraier::Database::ERRNOERR, 0, 0, 0},
04435 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRINVAL", (long) estraier::Database::ERRINVAL, 0, 0, 0},
04436 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRACCES", (long) estraier::Database::ERRACCES, 0, 0, 0},
04437 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRLOCK", (long) estraier::Database::ERRLOCK, 0, 0, 0},
04438 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRDB", (long) estraier::Database::ERRDB, 0, 0, 0},
04439 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRIO", (long) estraier::Database::ERRIO, 0, 0, 0},
04440 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRNOITEM", (long) estraier::Database::ERRNOITEM, 0, 0, 0},
04441 { SWIG_INT,     (char *) SWIG_prefix "Database_ERRMISC", (long) estraier::Database::ERRMISC, 0, 0, 0},
04442 { SWIG_INT,     (char *) SWIG_prefix "Database_DBREADER", (long) estraier::Database::DBREADER, 0, 0, 0},
04443 { SWIG_INT,     (char *) SWIG_prefix "Database_DBWRITER", (long) estraier::Database::DBWRITER, 0, 0, 0},
04444 { SWIG_INT,     (char *) SWIG_prefix "Database_DBCREAT", (long) estraier::Database::DBCREAT, 0, 0, 0},
04445 { SWIG_INT,     (char *) SWIG_prefix "Database_DBTRUNC", (long) estraier::Database::DBTRUNC, 0, 0, 0},
04446 { SWIG_INT,     (char *) SWIG_prefix "Database_DBNOLCK", (long) estraier::Database::DBNOLCK, 0, 0, 0},
04447 { SWIG_INT,     (char *) SWIG_prefix "Database_DBLCKNB", (long) estraier::Database::DBLCKNB, 0, 0, 0},
04448 { SWIG_INT,     (char *) SWIG_prefix "Database_DBPERFNG", (long) estraier::Database::DBPERFNG, 0, 0, 0},
04449 { SWIG_INT,     (char *) SWIG_prefix "Database_PDCLEAN", (long) estraier::Database::PDCLEAN, 0, 0, 0},
04450 { SWIG_INT,     (char *) SWIG_prefix "Database_ODCLEAN", (long) estraier::Database::ODCLEAN, 0, 0, 0},
04451 { SWIG_INT,     (char *) SWIG_prefix "Database_OPTNOPURGE", (long) estraier::Database::OPTNOPURGE, 0, 0, 0},
04452 { SWIG_INT,     (char *) SWIG_prefix "Database_OPTNODBOPT", (long) estraier::Database::OPTNODBOPT, 0, 0, 0},
04453 { SWIG_INT,     (char *) SWIG_prefix "Database_GDNOATTR", (long) estraier::Database::GDNOATTR, 0, 0, 0},
04454 { SWIG_INT,     (char *) SWIG_prefix "Database_GDNOTEXT", (long) estraier::Database::GDNOTEXT, 0, 0, 0},
04455 {0,0,0,0,0,0}
04456 };
04457 #ifdef __cplusplus
04458 }
04459 #endif
04460 static swig_variable_info swig_variables[] = {
04461 {0,0,0,0}
04462 };
04463 static swig_command_info swig_commands[] = {
04464 {"HyperEstraierc::new_StrVector", _wrap_new_StrVector},
04465 {"HyperEstraierc::StrVector_size", _wrap_StrVector_size},
04466 {"HyperEstraierc::StrVector_empty", _wrap_StrVector_empty},
04467 {"HyperEstraierc::StrVector_clear", _wrap_StrVector_clear},
04468 {"HyperEstraierc::StrVector_push", _wrap_StrVector_push},
04469 {"HyperEstraierc::StrVector_pop", _wrap_StrVector_pop},
04470 {"HyperEstraierc::StrVector_get", _wrap_StrVector_get},
04471 {"HyperEstraierc::StrVector_set", _wrap_StrVector_set},
04472 {"HyperEstraierc::delete_StrVector", _wrap_delete_StrVector},
04473 {"HyperEstraierc::new_IntVector", _wrap_new_IntVector},
04474 {"HyperEstraierc::IntVector_size", _wrap_IntVector_size},
04475 {"HyperEstraierc::IntVector_empty", _wrap_IntVector_empty},
04476 {"HyperEstraierc::IntVector_clear", _wrap_IntVector_clear},
04477 {"HyperEstraierc::IntVector_push", _wrap_IntVector_push},
04478 {"HyperEstraierc::IntVector_pop", _wrap_IntVector_pop},
04479 {"HyperEstraierc::IntVector_get", _wrap_IntVector_get},
04480 {"HyperEstraierc::IntVector_set", _wrap_IntVector_set},
04481 {"HyperEstraierc::delete_IntVector", _wrap_delete_IntVector},
04482 {"HyperEstraierc::new_StrStrMap", _wrap_new_StrStrMap},
04483 {"HyperEstraierc::StrStrMap_size", _wrap_StrStrMap_size},
04484 {"HyperEstraierc::StrStrMap_empty", _wrap_StrStrMap_empty},
04485 {"HyperEstraierc::StrStrMap_clear", _wrap_StrStrMap_clear},
04486 {"HyperEstraierc::StrStrMap_get", _wrap_StrStrMap_get},
04487 {"HyperEstraierc::StrStrMap_set", _wrap_StrStrMap_set},
04488 {"HyperEstraierc::StrStrMap_del", _wrap_StrStrMap_del},
04489 {"HyperEstraierc::StrStrMap_has_key", _wrap_StrStrMap_has_key},
04490 {"HyperEstraierc::delete_StrStrMap", _wrap_delete_StrStrMap},
04491 {"HyperEstraierc::Condition_cond_set", _wrap_Condition_cond_set},
04492 {"HyperEstraierc::Condition_cond_get", _wrap_Condition_cond_get},
04493 {"HyperEstraierc::new_Condition", _wrap_new_Condition},
04494 {"HyperEstraierc::delete_Condition", _wrap_delete_Condition},
04495 {"HyperEstraierc::Condition_set_phrase", _wrap_Condition_set_phrase},
04496 {"HyperEstraierc::Condition_add_attr", _wrap_Condition_add_attr},
04497 {"HyperEstraierc::Condition_set_order", _wrap_Condition_set_order},
04498 {"HyperEstraierc::Condition_set_max", _wrap_Condition_set_max},
04499 {"HyperEstraierc::Condition_set_options", _wrap_Condition_set_options},
04500 {"HyperEstraierc::Document_doc_set", _wrap_Document_doc_set},
04501 {"HyperEstraierc::Document_doc_get", _wrap_Document_doc_get},
04502 {"HyperEstraierc::new_Document", _wrap_new_Document},
04503 {"HyperEstraierc::delete_Document", _wrap_delete_Document},
04504 {"HyperEstraierc::Document_add_attr", _wrap_Document_add_attr},
04505 {"HyperEstraierc::Document_add_text", _wrap_Document_add_text},
04506 {"HyperEstraierc::Document_add_hidden_text", _wrap_Document_add_hidden_text},
04507 {"HyperEstraierc::Document_id", _wrap_Document_id},
04508 {"HyperEstraierc::Document_attr_names", _wrap_Document_attr_names},
04509 {"HyperEstraierc::Document_attr", _wrap_Document_attr},
04510 {"HyperEstraierc::Document_cat_texts", _wrap_Document_cat_texts},
04511 {"HyperEstraierc::Document_texts", _wrap_Document_texts},
04512 {"HyperEstraierc::Document_dump_draft", _wrap_Document_dump_draft},
04513 {"HyperEstraierc::Document_make_snippet", _wrap_Document_make_snippet},
04514 {"HyperEstraierc::new_Database", _wrap_new_Database},
04515 {"HyperEstraierc::delete_Database", _wrap_delete_Database},
04516 {"HyperEstraierc::Database_open", _wrap_Database_open},
04517 {"HyperEstraierc::Database_close", _wrap_Database_close},
04518 {"HyperEstraierc::Database_put_doc", _wrap_Database_put_doc},
04519 {"HyperEstraierc::Database_search", _wrap_Database_search},
04520 {"HyperEstraierc::Database_err_msg", _wrap_Database_err_msg},
04521 {"HyperEstraierc::Database_error", _wrap_Database_error},
04522 {"HyperEstraierc::Database_fatal", _wrap_Database_fatal},
04523 {"HyperEstraierc::Database_flush", _wrap_Database_flush},
04524 {"HyperEstraierc::Database_sync", _wrap_Database_sync},
04525 {"HyperEstraierc::Database_optimize", _wrap_Database_optimize},
04526 {"HyperEstraierc::Database_out_doc", _wrap_Database_out_doc},
04527 {"HyperEstraierc::Database_get_doc", _wrap_Database_get_doc},
04528 {"HyperEstraierc::Database_uri_to_id", _wrap_Database_uri_to_id},
04529 {"HyperEstraierc::Database_etch_doc", _wrap_Database_etch_doc},
04530 {"HyperEstraierc::Database_iter_init", _wrap_Database_iter_init},
04531 {"HyperEstraierc::Database_iter_next", _wrap_Database_iter_next},
04532 {"HyperEstraierc::Database_name", _wrap_Database_name},
04533 {"HyperEstraierc::Database_doc_num", _wrap_Database_doc_num},
04534 {"HyperEstraierc::Database_word_num", _wrap_Database_word_num},
04535 {"HyperEstraierc::Database_size", _wrap_Database_size},
04536 {"HyperEstraierc::Database_set_cache_size", _wrap_Database_set_cache_size},
04537 {"HyperEstraierc::Database_set_special_cache", _wrap_Database_set_special_cache},
04538 {0,0}
04539 };
04540 
04541 
04542 static void SWIG_Perl_SetTypeListHandle(swig_type_info **handle) {
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 }
04549 
04550 static swig_type_info **
04551 SWIG_Perl_LookupTypePointer(swig_type_info **type_list_handle) {
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 }
04564 
04565 
04566 #ifdef __cplusplus
04567 extern "C"
04568 #endif
04569 
04570 XS(SWIG_init) {
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 }
04634 

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