00001
00002
00003
00004
00005
00006
00007
00008
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
00039
00040
00041
00042
00043
00044
00045
00046
00047 #define SWIG_RUNTIME_VERSION "1"
00048
00049
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
00070
00071
00072
00073
00074
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
00102
00103
00104
00105
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
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
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
00143 tc = *tl;
00144 while (tc) {
00145
00146 int typeequiv = (strcmp(tc->name, ti->name) == 0);
00147
00148 if (!typeequiv) {
00149
00150 if (tc->str && ti->str && !strstr(tc->str,"|")) {
00151 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
00152 }
00153 }
00154 if (typeequiv) {
00155
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
00167 ti->prev = *tl;
00168 *tl = ti;
00169
00170
00171 l1:
00172 ret = head;
00173 tc = ti + 1;
00174
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
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;
00194 s = ty->next;
00195 do {
00196 if (strcmp(s->name,c) == 0) {
00197 if (s == ty->next) return s;
00198
00199 s->prev->next = s->next;
00200 if (s->next) {
00201 s->next->prev = s->prev;
00202 }
00203
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
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
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
00239
00240 SWIGRUNTIMEINLINE const char *
00241 SWIG_TypeName(const swig_type_info *ty) {
00242 return ty->name;
00243 }
00244
00245
00246
00247
00248
00249 SWIGRUNTIME const char *
00250 SWIG_TypePrettyName(const swig_type_info *type) {
00251
00252
00253
00254
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
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
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
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
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
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
00350
00351
00352
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
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
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
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
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
00472 static swig_type_info *
00473 SWIG_TypeRegister(swig_type_info *ti) {
00474 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
00475 }
00476
00477
00478 static swig_type_info *
00479 SWIG_TypeQuery(const char *name) {
00480 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
00481 }
00482
00483
00484 static void
00485 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00486 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
00487 }
00488
00489
00490
00491
00492
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
00504
00505
00506
00507
00508
00509
00510 #define SWIGPERL
00511 #define SWIGPERL5
00512 #ifdef __cplusplus
00513
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
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
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
00548
00549 #define SWIG_contract_assert(expr,msg) if (!(expr)) { SWIG_croak(msg); } else
00550
00551
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
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
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
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
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
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;
00702 s = ty->next;
00703 do {
00704 if (sv_derived_from(rv, (char *) s->name)) {
00705 if (s == ty->next) return s;
00706
00707 s->prev->next = s->next;
00708 if (s->next) {
00709 s->next->prev = s->prev;
00710 }
00711
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
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
00731 if (SvGMAGICAL(sv))
00732 mg_get(sv);
00733
00734
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)) {
00760 *(ptr) = (void *) 0;
00761 return 0;
00762 } else if (SvTYPE(sv) == SVt_RV) {
00763 *(ptr) = (void *) 0;
00764 if (!SvROK(sv))
00765 return 0;
00766 else
00767 return -1;
00768 } else {
00769 *(ptr) = (void *) 0;
00770 return -1;
00771 }
00772 if (_t) {
00773
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
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
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
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
00876
00877
00878
00879 typedef XS(SwigPerlWrapper);
00880 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
00881
00882
00883 typedef struct {
00884 const char *name;
00885 SwigPerlWrapperPtr wrapper;
00886 } swig_command_info;
00887
00888
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
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
00911 typedef struct {
00912 const char *name;
00913 SwigMagicFunc set;
00914 SwigMagicFunc get;
00915 swig_type_info **type;
00916 } swig_variable_info;
00917
00918
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
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
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
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
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
01358 _v = 1;
01359 } else {
01360
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);
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);
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
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
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
01912 _v = 1;
01913 } else {
01914
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
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
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
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
04555 type_pointer = SWIG_Perl_GetTypeListHandle();
04556 if (type_pointer) {
04557 return type_pointer;
04558 } else {
04559
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
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
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
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