/[hyperestraier_wrappers]/0.0.12/perl/HyperEstraier_wrap.cpp
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /0.0.12/perl/HyperEstraier_wrap.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (hide annotations)
Sat Sep 3 18:02:31 2005 UTC (18 years, 6 months ago) by dpavlin
File size: 135785 byte(s)
import of hyper_estraier_wrappers-0.0.12.tar.gz

1 dpavlin 1 /* ----------------------------------------------------------------------------
2     * This file was automatically generated by SWIG (http://www.swig.org).
3     * Version 1.3.24
4     *
5     * This file is not intended to be easily readable and contains a number of
6     * coding conventions designed to improve portability and efficiency. Do not make
7     * changes to this file unless you know what you are doing--modify the SWIG
8     * interface file instead.
9     * ----------------------------------------------------------------------------- */
10    
11    
12     #ifdef __cplusplus
13     template<class T> class SwigValueWrapper {
14     T *tt;
15     public:
16     SwigValueWrapper() : tt(0) { }
17     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
18     SwigValueWrapper(const T& t) : tt(new T(t)) { }
19     ~SwigValueWrapper() { delete tt; }
20     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
21     operator T&() const { return *tt; }
22     T *operator&() { return tt; }
23     private:
24     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25     };
26     #endif
27    
28    
29     #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
30     # if defined(__SUNPRO_CC)
31     # define SWIG_TEMPLATE_DISAMBIGUATOR template
32     # else
33     # define SWIG_TEMPLATE_DISAMBIGUATOR
34     # endif
35     #endif
36    
37     /***********************************************************************
38     * swigrun.swg
39     *
40     * This file contains generic CAPI SWIG runtime support for pointer
41     * type checking.
42     *
43     ************************************************************************/
44    
45     /* This should only be incremented when either the layout of swig_type_info changes,
46     or for whatever reason, the runtime changes incompatibly */
47     #define SWIG_RUNTIME_VERSION "1"
48    
49     /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
50     #ifdef SWIG_TYPE_TABLE
51     #define SWIG_QUOTE_STRING(x) #x
52     #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
53     #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
54     #else
55     #define SWIG_TYPE_TABLE_NAME
56     #endif
57    
58     #include <string.h>
59    
60     #ifndef SWIGINLINE
61     #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
62     # define SWIGINLINE inline
63     #else
64     # define SWIGINLINE
65     #endif
66     #endif
67    
68     /*
69     You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
70     creating a static or dynamic library from the swig runtime code.
71     In 99.9% of the cases, swig just needs to declare them as 'static'.
72    
73     But only do this if is strictly necessary, ie, if you have problems
74     with your compiler or so.
75     */
76     #ifndef SWIGRUNTIME
77     #define SWIGRUNTIME static
78     #endif
79     #ifndef SWIGRUNTIMEINLINE
80     #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
81     #endif
82    
83     #ifdef __cplusplus
84     extern "C" {
85     #endif
86    
87     typedef void *(*swig_converter_func)(void *);
88     typedef struct swig_type_info *(*swig_dycast_func)(void **);
89    
90     typedef struct swig_type_info {
91     const char *name;
92     swig_converter_func converter;
93     const char *str;
94     void *clientdata;
95     swig_dycast_func dcast;
96     struct swig_type_info *next;
97     struct swig_type_info *prev;
98     } swig_type_info;
99    
100     /*
101     Compare two type names skipping the space characters, therefore
102     "char*" == "char *" and "Class<int>" == "Class<int >", etc.
103    
104     Return 0 when the two name types are equivalent, as in
105     strncmp, but skipping ' '.
106     */
107     SWIGRUNTIME int
108     SWIG_TypeNameComp(const char *f1, const char *l1,
109     const char *f2, const char *l2) {
110     for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
111     while ((*f1 == ' ') && (f1 != l1)) ++f1;
112     while ((*f2 == ' ') && (f2 != l2)) ++f2;
113     if (*f1 != *f2) return *f1 - *f2;
114     }
115     return (l1 - f1) - (l2 - f2);
116     }
117    
118     /*
119     Check type equivalence in a name list like <name1>|<name2>|...
120     */
121     SWIGRUNTIME int
122     SWIG_TypeEquiv(const char *nb, const char *tb) {
123     int equiv = 0;
124     const char* te = tb + strlen(tb);
125     const char* ne = nb;
126     while (!equiv && *ne) {
127     for (nb = ne; *ne; ++ne) {
128     if (*ne == '|') break;
129     }
130     equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
131     if (*ne) ++ne;
132     }
133     return equiv;
134     }
135    
136     /*
137     Register a type mapping with the type-checking
138     */
139     SWIGRUNTIME swig_type_info *
140     SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
141     swig_type_info *tc, *head, *ret, *next;
142     /* Check to see if this type has already been registered */
143     tc = *tl;
144     while (tc) {
145     /* check simple type equivalence */
146     int typeequiv = (strcmp(tc->name, ti->name) == 0);
147     /* check full type equivalence, resolving typedefs */
148     if (!typeequiv) {
149     /* only if tc is not a typedef (no '|' on it) */
150     if (tc->str && ti->str && !strstr(tc->str,"|")) {
151     typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
152     }
153     }
154     if (typeequiv) {
155     /* Already exists in the table. Just add additional types to the list */
156     if (ti->clientdata) tc->clientdata = ti->clientdata;
157     head = tc;
158     next = tc->next;
159     goto l1;
160     }
161     tc = tc->prev;
162     }
163     head = ti;
164     next = 0;
165    
166     /* Place in list */
167     ti->prev = *tl;
168     *tl = ti;
169    
170     /* Build linked lists */
171     l1:
172     ret = head;
173     tc = ti + 1;
174     /* Patch up the rest of the links */
175     while (tc->name) {
176     head->next = tc;
177     tc->prev = head;
178     head = tc;
179     tc++;
180     }
181     if (next) next->prev = head;
182     head->next = next;
183    
184     return ret;
185     }
186    
187     /*
188     Check the typename
189     */
190     SWIGRUNTIME swig_type_info *
191     SWIG_TypeCheck(const char *c, swig_type_info *ty) {
192     swig_type_info *s;
193     if (!ty) return 0; /* Void pointer */
194     s = ty->next; /* First element always just a name */
195     do {
196     if (strcmp(s->name,c) == 0) {
197     if (s == ty->next) return s;
198     /* Move s to the top of the linked list */
199     s->prev->next = s->next;
200     if (s->next) {
201     s->next->prev = s->prev;
202     }
203     /* Insert s as second element in the list */
204     s->next = ty->next;
205     if (ty->next) ty->next->prev = s;
206     ty->next = s;
207     s->prev = ty;
208     return s;
209     }
210     s = s->next;
211     } while (s && (s != ty->next));
212     return 0;
213     }
214    
215     /*
216     Cast a pointer up an inheritance hierarchy
217     */
218     SWIGRUNTIMEINLINE void *
219     SWIG_TypeCast(swig_type_info *ty, void *ptr) {
220     return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
221     }
222    
223     /*
224     Dynamic pointer casting. Down an inheritance hierarchy
225     */
226     SWIGRUNTIME swig_type_info *
227     SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
228     swig_type_info *lastty = ty;
229     if (!ty || !ty->dcast) return ty;
230     while (ty && (ty->dcast)) {
231     ty = (*ty->dcast)(ptr);
232     if (ty) lastty = ty;
233     }
234     return lastty;
235     }
236    
237     /*
238     Return the name associated with this type
239     */
240     SWIGRUNTIMEINLINE const char *
241     SWIG_TypeName(const swig_type_info *ty) {
242     return ty->name;
243     }
244    
245     /*
246     Return the pretty name associated with this type,
247     that is an unmangled type name in a form presentable to the user.
248     */
249     SWIGRUNTIME const char *
250     SWIG_TypePrettyName(const swig_type_info *type) {
251     /* The "str" field contains the equivalent pretty names of the
252     type, separated by vertical-bar characters. We choose
253     to print the last name, as it is often (?) the most
254     specific. */
255     if (type->str != NULL) {
256     const char *last_name = type->str;
257     const char *s;
258     for (s = type->str; *s; s++)
259     if (*s == '|') last_name = s+1;
260     return last_name;
261     }
262     else
263     return type->name;
264     }
265    
266     /*
267     Search for a swig_type_info structure
268     */
269     SWIGRUNTIME swig_type_info *
270     SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
271     swig_type_info *ty = tl;
272     while (ty) {
273     if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
274     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
275     ty = ty->prev;
276     }
277     return 0;
278     }
279    
280     /*
281     Set the clientdata field for a type
282     */
283     SWIGRUNTIME void
284     SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
285     swig_type_info *tc, *equiv;
286     if (ti->clientdata) return;
287     /* if (ti->clientdata == clientdata) return; */
288     ti->clientdata = clientdata;
289     equiv = ti->next;
290     while (equiv) {
291     if (!equiv->converter) {
292     tc = tl;
293     while (tc) {
294     if ((strcmp(tc->name, equiv->name) == 0))
295     SWIG_TypeClientDataTL(tl,tc,clientdata);
296     tc = tc->prev;
297     }
298     }
299     equiv = equiv->next;
300     }
301     }
302    
303     /*
304     Pack binary data into a string
305     */
306     SWIGRUNTIME char *
307     SWIG_PackData(char *c, void *ptr, size_t sz) {
308     static char hex[17] = "0123456789abcdef";
309     unsigned char *u = (unsigned char *) ptr;
310     const unsigned char *eu = u + sz;
311     register unsigned char uu;
312     for (; u != eu; ++u) {
313     uu = *u;
314     *(c++) = hex[(uu & 0xf0) >> 4];
315     *(c++) = hex[uu & 0xf];
316     }
317     return c;
318     }
319    
320     /*
321     Unpack binary data from a string
322     */
323     SWIGRUNTIME const char *
324     SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
325     register unsigned char *u = (unsigned char *) ptr;
326     register const unsigned char *eu = u + sz;
327     for (; u != eu; ++u) {
328     register int d = *(c++);
329     register unsigned char uu = 0;
330     if ((d >= '0') && (d <= '9'))
331     uu = ((d - '0') << 4);
332     else if ((d >= 'a') && (d <= 'f'))
333     uu = ((d - ('a'-10)) << 4);
334     else
335     return (char *) 0;
336     d = *(c++);
337     if ((d >= '0') && (d <= '9'))
338     uu |= (d - '0');
339     else if ((d >= 'a') && (d <= 'f'))
340     uu |= (d - ('a'-10));
341     else
342     return (char *) 0;
343     *u = uu;
344     }
345     return c;
346     }
347    
348     /*
349     This function will propagate the clientdata field of type to any new
350     swig_type_info structures that have been added into the list of
351     equivalent types. It is like calling SWIG_TypeClientData(type,
352     clientdata) a second time.
353     */
354     SWIGRUNTIME void
355     SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
356     swig_type_info *equiv = type->next;
357     swig_type_info *tc;
358     if (!type->clientdata) return;
359     while (equiv) {
360     if (!equiv->converter) {
361     tc = tl;
362     while (tc) {
363     if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
364     SWIG_TypeClientDataTL(tl,tc, type->clientdata);
365     tc = tc->prev;
366     }
367     }
368     equiv = equiv->next;
369     }
370     }
371    
372     /*
373     Pack 'void *' into a string buffer.
374     */
375     SWIGRUNTIME char *
376     SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
377     char *r = buff;
378     if ((2*sizeof(void *) + 2) > bsz) return 0;
379     *(r++) = '_';
380     r = SWIG_PackData(r,&ptr,sizeof(void *));
381     if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
382     strcpy(r,name);
383     return buff;
384     }
385    
386     SWIGRUNTIME const char *
387     SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
388     if (*c != '_') {
389     if (strcmp(c,"NULL") == 0) {
390     *ptr = (void *) 0;
391     return name;
392     } else {
393     return 0;
394     }
395     }
396     return SWIG_UnpackData(++c,ptr,sizeof(void *));
397     }
398    
399     SWIGRUNTIME char *
400     SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
401     char *r = buff;
402     size_t lname = (name ? strlen(name) : 0);
403     if ((2*sz + 2 + lname) > bsz) return 0;
404     *(r++) = '_';
405     r = SWIG_PackData(r,ptr,sz);
406     if (lname) {
407     strncpy(r,name,lname+1);
408     } else {
409     *r = 0;
410     }
411     return buff;
412     }
413    
414     SWIGRUNTIME const char *
415     SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
416     if (*c != '_') {
417     if (strcmp(c,"NULL") == 0) {
418     memset(ptr,0,sz);
419     return name;
420     } else {
421     return 0;
422     }
423     }
424     return SWIG_UnpackData(++c,ptr,sz);
425     }
426    
427     #ifdef __cplusplus
428     }
429     #endif
430    
431     /***********************************************************************
432     * common.swg
433     *
434     * This file contains generic SWIG runtime support for pointer
435     * type checking as well as a few commonly used macros to control
436     * external linkage.
437     *
438     * Author : David Beazley (beazley@cs.uchicago.edu)
439     *
440     * Copyright (c) 1999-2000, The University of Chicago
441     *
442     * This file may be freely redistributed without license or fee provided
443     * this copyright message remains intact.
444     ************************************************************************/
445    
446    
447     #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
448     # if !defined(STATIC_LINKED)
449     # define SWIGEXPORT(a) __declspec(dllexport) a
450     # else
451     # define SWIGEXPORT(a) a
452     # endif
453     #else
454     # define SWIGEXPORT(a) a
455     #endif
456    
457     #ifdef __cplusplus
458     extern "C" {
459     #endif
460    
461    
462     /*************************************************************************/
463    
464    
465     /* The static type info list */
466    
467     static swig_type_info *swig_type_list = 0;
468     static swig_type_info **swig_type_list_handle = &swig_type_list;
469    
470    
471     /* Register a type mapping with the type-checking */
472     static swig_type_info *
473     SWIG_TypeRegister(swig_type_info *ti) {
474     return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
475     }
476    
477     /* Search for a swig_type_info structure */
478     static swig_type_info *
479     SWIG_TypeQuery(const char *name) {
480     return SWIG_TypeQueryTL(*swig_type_list_handle, name);
481     }
482    
483     /* Set the clientdata field for a type */
484     static void
485     SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
486     SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
487     }
488    
489     /* This function will propagate the clientdata field of type to
490     * any new swig_type_info structures that have been added into the list
491     * of equivalent types. It is like calling
492     * SWIG_TypeClientData(type, clientdata) a second time.
493     */
494     static void
495     SWIG_PropagateClientData(swig_type_info *type) {
496     SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
497     }
498    
499     #ifdef __cplusplus
500     }
501     #endif
502    
503     /* ---------------------------------------------------------------------- -*- c -*-
504     * perl5.swg
505     *
506     * Perl5 runtime library
507     * $Header: /cvsroot/swig/SWIG/Lib/perl5/perlrun.swg,v 1.20 2004/11/29 23:13:57 wuzzeb Exp $
508     * ----------------------------------------------------------------------------- */
509    
510     #define SWIGPERL
511     #define SWIGPERL5
512     #ifdef __cplusplus
513     /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
514     #include <math.h>
515     #include <stdlib.h>
516     extern "C" {
517     #endif
518     #include "EXTERN.h"
519     #include "perl.h"
520     #include "XSUB.h"
521    
522     /* Get rid of free and malloc defined by perl */
523     #undef free
524     #undef malloc
525    
526     #ifndef pTHX_
527     #define pTHX_
528     #endif
529    
530     #include <string.h>
531     #ifdef __cplusplus
532     }
533     #endif
534    
535     /* Macro to call an XS function */
536    
537     #ifdef PERL_OBJECT
538     # define SWIG_CALLXS(_name) _name(cv,pPerl)
539     #else
540     # ifndef MULTIPLICITY
541     # define SWIG_CALLXS(_name) _name(cv)
542     # else
543     # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
544     # endif
545     #endif
546    
547     /* Contract support */
548    
549     #define SWIG_contract_assert(expr,msg) if (!(expr)) { SWIG_croak(msg); } else
550    
551     /* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
552    
553     #ifdef PERL_OBJECT
554     #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
555     typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
556    
557     #ifdef __cplusplus
558     extern "C" {
559     #endif
560     typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
561     #ifdef __cplusplus
562     }
563     #endif
564    
565     #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
566     #define SWIGCLASS_STATIC
567     #else
568     #define MAGIC_PPERL
569     #define SWIGCLASS_STATIC static
570     #ifndef MULTIPLICITY
571     #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
572     typedef int (*SwigMagicFunc)(SV *, MAGIC *);
573    
574     #ifdef __cplusplus
575     extern "C" {
576     #endif
577     typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
578     #ifdef __cplusplus
579     }
580     #endif
581    
582    
583     #else
584     #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
585     typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
586     #ifdef __cplusplus
587     extern "C" {
588     #endif
589     typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
590     #ifdef __cplusplus
591     }
592     #endif
593    
594     #endif
595     #endif
596    
597     #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
598     #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
599     #endif
600    
601     /* Modifications for newer Perl 5.005 releases */
602    
603     #if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
604     # ifndef PL_sv_yes
605     # define PL_sv_yes sv_yes
606     # endif
607     # ifndef PL_sv_undef
608     # define PL_sv_undef sv_undef
609     # endif
610     # ifndef PL_na
611     # define PL_na na
612     # endif
613     #endif
614    
615     #include <stdlib.h>
616    
617     #ifdef __cplusplus
618     extern "C" {
619     #endif
620    
621     #define SWIG_OWNER 1
622     #define SWIG_SHADOW 2
623    
624     /* Common SWIG API */
625    
626     #ifdef PERL_OBJECT
627     # define SWIG_ConvertPtr(obj, pp, type, flags) \
628     SWIG_Perl_ConvertPtr(pPerl, obj, pp, type, flags)
629     # define SWIG_NewPointerObj(p, type, flags) \
630     SWIG_Perl_NewPointerObj(pPerl, p, type, flags)
631     # define SWIG_MakePackedObj(sv, p, s, type) \
632     SWIG_Perl_MakePackedObj(pPerl, sv, p, s, type)
633     # define SWIG_ConvertPacked(obj, p, s, type, flags) \
634     SWIG_Perl_ConvertPacked(pPerl, obj, p, s, type, flags)
635    
636     #else
637     # define SWIG_ConvertPtr(obj, pp, type, flags) \
638     SWIG_Perl_ConvertPtr(obj, pp, type, flags)
639     # define SWIG_NewPointerObj(p, type, flags) \
640     SWIG_Perl_NewPointerObj(p, type, flags)
641     # define SWIG_MakePackedObj(sv, p, s, type) \
642     SWIG_Perl_MakePackedObj(sv, p, s, type )
643     # define SWIG_ConvertPacked(obj, p, s, type, flags) \
644     SWIG_Perl_ConvertPacked(obj, p, s, type, flags)
645     #endif
646    
647     /* Perl-specific API */
648     #ifdef PERL_OBJECT
649     # define SWIG_MakePtr(sv, ptr, type, flags) \
650     SWIG_Perl_MakePtr(pPerl, sv, ptr, type, flags)
651     # define SWIG_SetError(str) \
652     SWIG_Perl_SetError(pPerl, str)
653     #else
654     # define SWIG_MakePtr(sv, ptr, type, flags) \
655     SWIG_Perl_MakePtr(sv, ptr, type, flags)
656     # define SWIG_SetError(str) \
657     SWIG_Perl_SetError(str)
658     # define SWIG_SetErrorSV(str) \
659     SWIG_Perl_SetErrorSV(str)
660     #endif
661    
662     #define SWIG_SetErrorf SWIG_Perl_SetErrorf
663    
664    
665     #ifdef PERL_OBJECT
666     # define SWIG_MAYBE_PERL_OBJECT CPerlObj *pPerl,
667     #else
668     # define SWIG_MAYBE_PERL_OBJECT
669     #endif
670    
671     static swig_type_info **
672     SWIG_Perl_GetTypeListHandle() {
673     static void *type_pointer = (void *)0;
674     SV *pointer;
675    
676     /* first check if pointer already created */
677     if (!type_pointer) {
678     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
679     if (pointer && SvOK(pointer)) {
680     type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
681     }
682     }
683    
684     return (swig_type_info **) type_pointer;
685     }
686    
687     /*
688     Search for a swig_type_info structure
689     */
690     SWIGRUNTIMEINLINE swig_type_info *
691     SWIG_Perl_GetTypeList() {
692     swig_type_info **tlh = SWIG_Perl_GetTypeListHandle();
693     return tlh ? *tlh : (swig_type_info*)0;
694     }
695    
696     #define SWIG_Runtime_GetTypeList SWIG_Perl_GetTypeList
697    
698     static swig_type_info *
699     SWIG_Perl_TypeCheckRV(SWIG_MAYBE_PERL_OBJECT SV *rv, swig_type_info *ty) {
700     swig_type_info *s;
701     if (!ty) return 0; /* Void pointer */
702     s = ty->next; /* First element always just a name */
703     do {
704     if (sv_derived_from(rv, (char *) s->name)) {
705     if (s == ty->next) return s;
706     /* Move s to the top of the linked list */
707     s->prev->next = s->next;
708     if (s->next) {
709     s->next->prev = s->prev;
710     }
711     /* Insert s as second element in the list */
712     s->next = ty->next;
713     if (ty->next) ty->next->prev = s;
714     ty->next = s;
715     s->prev = ty;
716     return s;
717     }
718     s = s->next;
719     } while (s && (s != ty->next));
720     return 0;
721     }
722    
723     /* Function for getting a pointer value */
724    
725     static int
726     SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
727     swig_type_info *tc;
728     void *voidptr = (void *)0;
729    
730     /* If magical, apply more magic */
731     if (SvGMAGICAL(sv))
732     mg_get(sv);
733    
734     /* Check to see if this is an object */
735     if (sv_isobject(sv)) {
736     SV *tsv = (SV*) SvRV(sv);
737     IV tmp = 0;
738     if ((SvTYPE(tsv) == SVt_PVHV)) {
739     MAGIC *mg;
740     if (SvMAGICAL(tsv)) {
741     mg = mg_find(tsv,'P');
742     if (mg) {
743     sv = mg->mg_obj;
744     if (sv_isobject(sv)) {
745     tmp = SvIV((SV*)SvRV(sv));
746     }
747     }
748     } else {
749     return -1;
750     }
751     } else {
752     tmp = SvIV((SV*)SvRV(sv));
753     }
754     voidptr = (void *)tmp;
755     if (!_t) {
756     *(ptr) = voidptr;
757     return 0;
758     }
759     } else if (! SvOK(sv)) { /* Check for undef */
760     *(ptr) = (void *) 0;
761     return 0;
762     } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
763     *(ptr) = (void *) 0;
764     if (!SvROK(sv))
765     return 0;
766     else
767     return -1;
768     } else { /* Don't know what it is */
769     *(ptr) = (void *) 0;
770     return -1;
771     }
772     if (_t) {
773     /* Now see if the types match */
774     char *_c = HvNAME(SvSTASH(SvRV(sv)));
775     tc = SWIG_TypeCheck(_c,_t);
776     if (!tc) {
777     *ptr = voidptr;
778     return -1;
779     }
780     *ptr = SWIG_TypeCast(tc,voidptr);
781     return 0;
782     }
783     *ptr = voidptr;
784     return 0;
785     }
786    
787     static void
788     SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
789     if (ptr && (flags & SWIG_SHADOW)) {
790     SV *self;
791     SV *obj=newSV(0);
792     HV *hash=newHV();
793     HV *stash;
794     sv_setref_pv(obj, (char *) t->name, ptr);
795     stash=SvSTASH(SvRV(obj));
796     if (flags & SWIG_OWNER) {
797     HV *hv;
798     GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
799     if (!isGV(gv))
800     gv_init(gv, stash, "OWNER", 5, FALSE);
801     hv=GvHVn(gv);
802     hv_store_ent(hv, obj, newSViv(1), 0);
803     }
804     sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
805     SvREFCNT_dec(obj);
806     self=newRV_noinc((SV *)hash);
807     sv_setsv(sv, self);
808     SvREFCNT_dec((SV *)self);
809     sv_bless(sv, stash);
810     }
811     else {
812     sv_setref_pv(sv, (char *) t->name, ptr);
813     }
814     }
815    
816     static SWIGINLINE SV *
817     SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
818     SV *result = sv_newmortal();
819     SWIG_MakePtr(result, ptr, t, flags);
820     return result;
821     }
822    
823     static void
824     SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
825     char result[1024];
826     char *r = result;
827     if ((2*sz + 1 + strlen(type->name)) > 1000) return;
828     *(r++) = '_';
829     r = SWIG_PackData(r,ptr,sz);
830     strcpy(r,type->name);
831     sv_setpv(sv, result);
832     }
833    
834     /* Convert a packed value value */
835     static int
836     SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
837     swig_type_info *tc;
838     const char *c = 0;
839    
840     if ((!obj) || (!SvOK(obj))) return -1;
841     c = SvPV(obj, PL_na);
842     /* Pointer values must start with leading underscore */
843     if (*c != '_') return -1;
844     c++;
845     c = SWIG_UnpackData(c,ptr,sz);
846     if (ty) {
847     tc = SWIG_TypeCheck(c,ty);
848     if (!tc) return -1;
849     }
850     return 0;
851     }
852    
853     static SWIGINLINE void
854     SWIG_Perl_SetError(SWIG_MAYBE_PERL_OBJECT const char *error) {
855     if (error) sv_setpv(perl_get_sv("@", TRUE), error);
856     }
857    
858     static SWIGINLINE void
859     SWIG_Perl_SetErrorSV(SWIG_MAYBE_PERL_OBJECT SV *error) {
860     if (error) sv_setsv(perl_get_sv("@", TRUE), error);
861     }
862    
863     static void
864     SWIG_Perl_SetErrorf(const char *fmt, ...) {
865     va_list args;
866     va_start(args, fmt);
867     sv_vsetpvfn(perl_get_sv("@", TRUE), fmt, strlen(fmt), &args, Null(SV**), 0, Null(bool*));
868     va_end(args);
869     }
870    
871     /* Macros for low-level exception handling */
872     #define SWIG_fail goto fail
873     #define SWIG_croak(x) { SWIG_SetError(x); goto fail; }
874     #define SWIG_croakSV(x) { SWIG_SetErrorSV(x); goto fail; }
875     /* most preprocessors do not support vararg macros :-( */
876     /* #define SWIG_croakf(x...) { SWIG_SetErrorf(x); goto fail; } */
877    
878    
879     typedef XS(SwigPerlWrapper);
880     typedef SwigPerlWrapper *SwigPerlWrapperPtr;
881    
882     /* Structure for command table */
883     typedef struct {
884     const char *name;
885     SwigPerlWrapperPtr wrapper;
886     } swig_command_info;
887    
888     /* Information for constant table */
889    
890     #define SWIG_INT 1
891     #define SWIG_FLOAT 2
892     #define SWIG_STRING 3
893     #define SWIG_POINTER 4
894     #define SWIG_BINARY 5
895    
896     /* Constant information structure */
897     typedef struct swig_constant_info {
898     int type;
899     const char *name;
900     long lvalue;
901     double dvalue;
902     void *pvalue;
903     swig_type_info **ptype;
904     } swig_constant_info;
905    
906     #ifdef __cplusplus
907     }
908     #endif
909    
910     /* Structure for variable table */
911     typedef struct {
912     const char *name;
913     SwigMagicFunc set;
914     SwigMagicFunc get;
915     swig_type_info **type;
916     } swig_variable_info;
917    
918     /* Magic variable code */
919     #ifndef PERL_OBJECT
920     #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
921     #ifndef MULTIPLICITY
922     static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
923     #else
924     static void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) {
925     #endif
926     #else
927     # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
928     static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
929     #endif
930     MAGIC *mg;
931     sv_magic(sv,sv,'U',(char *) name,strlen(name));
932     mg = mg_find(sv,'U');
933     mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
934     mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
935     mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
936     mg->mg_virtual->svt_len = 0;
937     mg->mg_virtual->svt_clear = 0;
938     mg->mg_virtual->svt_free = 0;
939     }
940    
941    
942    
943    
944    
945    
946     #ifdef do_open
947     #undef do_open
948     #endif
949     #ifdef do_close
950     #undef do_close
951     #endif
952     #ifdef scalar
953     #undef scalar
954     #endif
955     #ifdef list
956     #undef list
957     #endif
958     #ifdef apply
959     #undef apply
960     #endif
961     #ifdef convert
962     #undef convert
963     #endif
964     #ifdef Error
965     #undef Error
966     #endif
967     #ifdef form
968     #undef form
969     #endif
970     #ifdef vform
971     #undef vform
972     #endif
973     #ifdef LABEL
974     #undef LABEL
975     #endif
976     #ifdef METHOD
977     #undef METHOD
978     #endif
979     #ifdef Move
980     #undef Move
981     #endif
982     #ifdef yylex
983     #undef yylex
984     #endif
985     #ifdef yyparse
986     #undef yyparse
987     #endif
988     #ifdef yyerror
989     #undef yyerror
990     #endif
991     #ifdef invert
992     #undef invert
993     #endif
994     #ifdef ref
995     #undef ref
996     #endif
997     #ifdef ENTER
998     #undef ENTER
999     #endif
1000    
1001    
1002     /* -------- TYPES TABLE (BEGIN) -------- */
1003    
1004     #define SWIGTYPE_p_estraier__Condition swig_types[0]
1005     #define SWIGTYPE_p_ESTCOND swig_types[1]
1006     #define SWIGTYPE_p_estraier__Database swig_types[2]
1007     #define SWIGTYPE_p_ESTDOC swig_types[3]
1008     #define SWIGTYPE_p_std__vectorTstd__string_t swig_types[4]
1009     #define SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[5]
1010     #define SWIGTYPE_p_std__vectorTint_t swig_types[6]
1011     #define SWIGTYPE_p_std__string swig_types[7]
1012     #define SWIGTYPE_p_estraier__Document swig_types[8]
1013     #define SWIGTYPE_p_size_t swig_types[9]
1014     static swig_type_info *swig_types[11];
1015    
1016     /* -------- TYPES TABLE (END) -------- */
1017    
1018     #define SWIG_init boot_HyperEstraier
1019    
1020     #define SWIG_name "HyperEstraierc::boot_HyperEstraier"
1021     #define SWIG_prefix "HyperEstraierc::"
1022    
1023     #ifdef __cplusplus
1024     extern "C"
1025     #endif
1026     #ifndef PERL_OBJECT
1027     #ifndef MULTIPLICITY
1028     SWIGEXPORT(void) SWIG_init (CV* cv);
1029     #else
1030     SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
1031     #endif
1032     #else
1033     SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
1034     #endif
1035    
1036    
1037     #define SWIG_MemoryError 1
1038     #define SWIG_IOError 2
1039     #define SWIG_RuntimeError 3
1040     #define SWIG_IndexError 4
1041     #define SWIG_TypeError 5
1042     #define SWIG_DivisionByZero 6
1043     #define SWIG_OverflowError 7
1044     #define SWIG_SyntaxError 8
1045     #define SWIG_ValueError 9
1046     #define SWIG_SystemError 10
1047     #define SWIG_UnknownError 99
1048    
1049    
1050     #define SWIG_exception(a,b) SWIG_croak(b)
1051    
1052    
1053     #include <stdexcept>
1054    
1055    
1056     #include <string>
1057    
1058     double SwigSvToNumber(SV* sv) {
1059     return SvIOK(sv) ? double(SvIVX(sv)) : SvNVX(sv);
1060     }
1061     std::string SwigSvToString(SV* sv) {
1062     STRLEN len;
1063     return SvPV(sv,len);
1064     }
1065     void SwigSvFromString(SV* sv, const std::string& s) {
1066     sv_setpv(sv,s.c_str());
1067     }
1068    
1069    
1070     #include <string>
1071    
1072    
1073     #include <vector>
1074     #include <algorithm>
1075     #include <stdexcept>
1076    
1077    
1078     #include <map>
1079     #include <algorithm>
1080     #include <stdexcept>
1081    
1082    
1083     #include <utility>
1084    
1085     static std::string std_vector_Sl_std_string_Sg__pop(std::vector<std::string > *self){
1086     if (self->size() == 0)
1087     throw std::out_of_range("pop from empty vector");
1088     std::string x = self->back();
1089     self->pop_back();
1090     return x;
1091     }
1092     static std::string std_vector_Sl_std_string_Sg__get(std::vector<std::string > *self,int i){
1093     int size = int(self->size());
1094     if (i>=0 && i<size)
1095     return (*self)[i];
1096     else
1097     throw std::out_of_range("vector index out of range");
1098     }
1099     static void std_vector_Sl_std_string_Sg__set(std::vector<std::string > *self,int i,std::string x){
1100     int size = int(self->size());
1101     if (i>=0 && i<size)
1102     (*self)[i] = x;
1103     else
1104     throw std::out_of_range("vector index out of range");
1105     }
1106     static int std_vector_Sl_int_Sg__pop(std::vector<int > *self){
1107     if (self->size() == 0)
1108     throw std::out_of_range("pop from empty vector");
1109     int x = self->back();
1110     self->pop_back();
1111     return x;
1112     }
1113     static int std_vector_Sl_int_Sg__get(std::vector<int > *self,int i){
1114     int size = int(self->size());
1115     if (i>=0 && i<size)
1116     return (*self)[i];
1117     else
1118     throw std::out_of_range("vector index out of range");
1119     }
1120     static void std_vector_Sl_int_Sg__set(std::vector<int > *self,int i,int x){
1121     int size = int(self->size());
1122     if (i>=0 && i<size)
1123     (*self)[i] = x;
1124     else
1125     throw std::out_of_range("vector index out of range");
1126     }
1127     static std::string &std_map_Sl_std_string_Sc_std_string_Sg__get(std::map<std::string,std::string > *self,std::string const &key){
1128     std::map<std::string,std::string >::iterator i = self->find(key);
1129     if (i != self->end())
1130     return i->second;
1131     else
1132     throw std::out_of_range("key not found");
1133     }
1134     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){
1135     (*self)[key] = x;
1136     }
1137     static void std_map_Sl_std_string_Sc_std_string_Sg__del(std::map<std::string,std::string > *self,std::string const &key){
1138     std::map<std::string,std::string >::iterator i = self->find(key);
1139     if (i != self->end())
1140     self->erase(i);
1141     else
1142     throw std::out_of_range("key not found");
1143     }
1144     static bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map<std::string,std::string > *self,std::string const &key){
1145     std::map<std::string,std::string >::iterator i = self->find(key);
1146     return i != self->end();
1147     }
1148    
1149     #include "HyperEstraierWrapper.cpp"
1150    
1151     #ifdef PERL_OBJECT
1152     #define MAGIC_CLASS _wrap_HyperEstraier_var::
1153     class _wrap_HyperEstraier_var : public CPerlObj {
1154     public:
1155     #else
1156     #define MAGIC_CLASS
1157     #endif
1158     SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
1159     MAGIC_PPERL
1160     sv = sv; mg = mg;
1161     croak("Value is read-only.");
1162     return 0;
1163     }
1164    
1165    
1166     #ifdef PERL_OBJECT
1167     };
1168     #endif
1169    
1170     #ifdef __cplusplus
1171     extern "C" {
1172     #endif
1173     XS(_wrap_new_StrVector__SWIG_0) {
1174     {
1175     unsigned int arg1 ;
1176     std::vector<std::string > *result;
1177     int argvi = 0;
1178     dXSARGS;
1179    
1180     if ((items < 1) || (items > 1)) {
1181     SWIG_croak("Usage: new_StrVector(size);");
1182     }
1183     arg1 = (unsigned int) SvUV(ST(0));
1184     {
1185     try {
1186     result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1187    
1188     } catch (const char *msg) {
1189     SWIG_exception(SWIG_RuntimeError, msg);
1190     }
1191     }
1192     ST(argvi) = sv_newmortal();
1193     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
1194     XSRETURN(argvi);
1195     fail:
1196     ;
1197     }
1198     croak(Nullch);
1199     }
1200    
1201    
1202     XS(_wrap_new_StrVector__SWIG_1) {
1203     {
1204     std::vector<std::string > *result;
1205     int argvi = 0;
1206     dXSARGS;
1207    
1208     if ((items < 0) || (items > 0)) {
1209     SWIG_croak("Usage: new_StrVector();");
1210     }
1211     {
1212     try {
1213     result = (std::vector<std::string > *)new std::vector<std::string >();
1214    
1215     } catch (const char *msg) {
1216     SWIG_exception(SWIG_RuntimeError, msg);
1217     }
1218     }
1219     ST(argvi) = sv_newmortal();
1220     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
1221     XSRETURN(argvi);
1222     fail:
1223     ;
1224     }
1225     croak(Nullch);
1226     }
1227    
1228    
1229     XS(_wrap_new_StrVector__SWIG_2) {
1230     {
1231     unsigned int arg1 ;
1232     std::string arg2 ;
1233     std::vector<std::string > *result;
1234     int argvi = 0;
1235     dXSARGS;
1236    
1237     if ((items < 2) || (items > 2)) {
1238     SWIG_croak("Usage: new_StrVector(size,value);");
1239     }
1240     arg1 = (unsigned int) SvUV(ST(0));
1241     {
1242     STRLEN len;
1243     const char *ptr = SvPV(ST(1), len);
1244     if (!ptr) {
1245     SWIG_croak("Undefined variable in argument 2 of new_StrVector.");
1246     } else {
1247     arg2 = std::string(ptr, len);
1248     }
1249     }
1250     {
1251     try {
1252     result = (std::vector<std::string > *)new std::vector<std::string >(arg1,arg2);
1253    
1254     } catch (const char *msg) {
1255     SWIG_exception(SWIG_RuntimeError, msg);
1256     }
1257     }
1258     ST(argvi) = sv_newmortal();
1259     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
1260     XSRETURN(argvi);
1261     fail:
1262     ;
1263     }
1264     croak(Nullch);
1265     }
1266    
1267    
1268     XS(_wrap_new_StrVector__SWIG_3) {
1269     {
1270     std::vector<std::string > *arg1 = 0 ;
1271     std::vector<std::string > *result;
1272     std::vector<std::string > temp1 ;
1273     std::vector<std::string > *v1 ;
1274     int argvi = 0;
1275     dXSARGS;
1276    
1277     if ((items < 1) || (items > 1)) {
1278     SWIG_croak("Usage: new_StrVector(std::vector<std::string > const &);");
1279     }
1280     {
1281     if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1282     SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
1283     arg1 = v1;
1284     } else if (SvROK(ST(0))) {
1285     AV *av = (AV *)SvRV(ST(0));
1286     if (SvTYPE(av) != SVt_PVAV)
1287     SWIG_croak("Type error in argument 1 of new_StrVector. "
1288     "Expected an array of ""std::string");
1289     SV **tv;
1290     I32 len = av_len(av) + 1;
1291     std::string* obj;
1292     for (int i=0; i<len; i++) {
1293     tv = av_fetch(av, i, 0);
1294     if (SvPOK(*tv)) {
1295     temp1.push_back(SvPVX(*tv));
1296     } else {
1297     SWIG_croak("Type error in argument 1 of "
1298     "new_StrVector. "
1299     "Expected an array of ""std::string");
1300     }
1301     }
1302     arg1 = &temp1;
1303     } else {
1304     SWIG_croak("Type error in argument 1 of new_StrVector. "
1305     "Expected an array of ""std::string");
1306     }
1307     }
1308     {
1309     try {
1310     result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1311    
1312     } catch (const char *msg) {
1313     SWIG_exception(SWIG_RuntimeError, msg);
1314     }
1315     }
1316     ST(argvi) = sv_newmortal();
1317     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|SWIG_OWNER);
1318     XSRETURN(argvi);
1319     fail:
1320     ;
1321     }
1322     croak(Nullch);
1323     }
1324    
1325    
1326     XS(_wrap_new_StrVector) {
1327     dXSARGS;
1328    
1329     if (items == 0) {
1330     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_1); return;
1331     }
1332     if (items == 1) {
1333     int _v;
1334     {
1335     _v = SvIOK(ST(0)) ? 1 : 0;
1336     }
1337     if (_v) {
1338     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_0); return;
1339     }
1340     }
1341     if (items == 1) {
1342     int _v;
1343     {
1344     {
1345     /* wrapped vector? */
1346     std::vector<std::string >* v;
1347     if (SWIG_ConvertPtr(ST(0),(void **) &v,
1348     SWIGTYPE_p_std__vectorTstd__string_t,0) != -1) {
1349     _v = 1;
1350     } else if (SvROK(ST(0))) {
1351     /* native sequence? */
1352     AV *av = (AV *)SvRV(ST(0));
1353     if (SvTYPE(av) == SVt_PVAV) {
1354     SV **tv;
1355     I32 len = av_len(av) + 1;
1356     if (len == 0) {
1357     /* an empty sequence can be of any type */
1358     _v = 1;
1359     } else {
1360     /* check the first element only */
1361     tv = av_fetch(av, 0, 0);
1362     if (SvPOK(*tv))
1363     _v = 1;
1364     else
1365     _v = 0;
1366     }
1367     }
1368     } else {
1369     _v = 0;
1370     }
1371     }
1372     }
1373     if (_v) {
1374     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_3); return;
1375     }
1376     }
1377     if (items == 2) {
1378     int _v;
1379     {
1380     _v = SvIOK(ST(0)) ? 1 : 0;
1381     }
1382     if (_v) {
1383     {
1384     _v = SvPOK(ST(1)) ? 1 : 0;
1385     }
1386     if (_v) {
1387     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrVector__SWIG_2); return;
1388     }
1389     }
1390     }
1391    
1392     croak("No matching function for overloaded 'new_StrVector'");
1393     XSRETURN(0);
1394     }
1395    
1396    
1397     XS(_wrap_StrVector_size) {
1398     {
1399     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1400     unsigned int result;
1401     std::vector<std::string > temp1 ;
1402     std::vector<std::string > *v1 ;
1403     int argvi = 0;
1404     dXSARGS;
1405    
1406     if ((items < 1) || (items > 1)) {
1407     SWIG_croak("Usage: StrVector_size(self);");
1408     }
1409     {
1410     if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1411     SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
1412     arg1 = v1;
1413     } else if (SvROK(ST(0))) {
1414     AV *av = (AV *)SvRV(ST(0));
1415     if (SvTYPE(av) != SVt_PVAV)
1416     SWIG_croak("Type error in argument 1 of StrVector_size. "
1417     "Expected an array of ""std::string");
1418     SV **tv;
1419     I32 len = av_len(av) + 1;
1420     std::string* obj;
1421     for (int i=0; i<len; i++) {
1422     tv = av_fetch(av, i, 0);
1423     if (SvPOK(*tv)) {
1424     temp1.push_back(SvPVX(*tv));
1425     } else {
1426     SWIG_croak("Type error in argument 1 of "
1427     "StrVector_size. "
1428     "Expected an array of ""std::string");
1429     }
1430     }
1431     arg1 = &temp1;
1432     } else {
1433     SWIG_croak("Type error in argument 1 of StrVector_size. "
1434     "Expected an array of ""std::string");
1435     }
1436     }
1437     {
1438     try {
1439     result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1440    
1441     } catch (const char *msg) {
1442     SWIG_exception(SWIG_RuntimeError, msg);
1443     }
1444     }
1445     ST(argvi) = sv_newmortal();
1446     sv_setuv(ST(argvi++), (UV) result);
1447     XSRETURN(argvi);
1448     fail:
1449     ;
1450     }
1451     croak(Nullch);
1452     }
1453    
1454    
1455     XS(_wrap_StrVector_empty) {
1456     {
1457     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1458     bool result;
1459     std::vector<std::string > temp1 ;
1460     std::vector<std::string > *v1 ;
1461     int argvi = 0;
1462     dXSARGS;
1463    
1464     if ((items < 1) || (items > 1)) {
1465     SWIG_croak("Usage: StrVector_empty(self);");
1466     }
1467     {
1468     if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1469     SWIGTYPE_p_std__vectorTstd__string_t,1) != -1) {
1470     arg1 = v1;
1471     } else if (SvROK(ST(0))) {
1472     AV *av = (AV *)SvRV(ST(0));
1473     if (SvTYPE(av) != SVt_PVAV)
1474     SWIG_croak("Type error in argument 1 of StrVector_empty. "
1475     "Expected an array of ""std::string");
1476     SV **tv;
1477     I32 len = av_len(av) + 1;
1478     std::string* obj;
1479     for (int i=0; i<len; i++) {
1480     tv = av_fetch(av, i, 0);
1481     if (SvPOK(*tv)) {
1482     temp1.push_back(SvPVX(*tv));
1483     } else {
1484     SWIG_croak("Type error in argument 1 of "
1485     "StrVector_empty. "
1486     "Expected an array of ""std::string");
1487     }
1488     }
1489     arg1 = &temp1;
1490     } else {
1491     SWIG_croak("Type error in argument 1 of StrVector_empty. "
1492     "Expected an array of ""std::string");
1493     }
1494     }
1495     {
1496     try {
1497     result = (bool)((std::vector<std::string > const *)arg1)->empty();
1498    
1499     } catch (const char *msg) {
1500     SWIG_exception(SWIG_RuntimeError, msg);
1501     }
1502     }
1503     ST(argvi) = sv_newmortal();
1504     sv_setiv(ST(argvi++), (IV) result);
1505     XSRETURN(argvi);
1506     fail:
1507     ;
1508     }
1509     croak(Nullch);
1510     }
1511    
1512    
1513     XS(_wrap_StrVector_clear) {
1514     {
1515     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1516     int argvi = 0;
1517     dXSARGS;
1518    
1519     if ((items < 1) || (items > 1)) {
1520     SWIG_croak("Usage: StrVector_clear(self);");
1521     }
1522     {
1523     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1524     SWIG_croak("Type error in argument 1 of StrVector_clear. Expected _p_std__vectorTstd__string_t");
1525     }
1526     }
1527     {
1528     try {
1529     (arg1)->clear();
1530    
1531     } catch (const char *msg) {
1532     SWIG_exception(SWIG_RuntimeError, msg);
1533     }
1534     }
1535    
1536     XSRETURN(argvi);
1537     fail:
1538     ;
1539     }
1540     croak(Nullch);
1541     }
1542    
1543    
1544     XS(_wrap_StrVector_push) {
1545     {
1546     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1547     std::string arg2 ;
1548     int argvi = 0;
1549     dXSARGS;
1550    
1551     if ((items < 2) || (items > 2)) {
1552     SWIG_croak("Usage: StrVector_push(self,x);");
1553     }
1554     {
1555     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1556     SWIG_croak("Type error in argument 1 of StrVector_push. Expected _p_std__vectorTstd__string_t");
1557     }
1558     }
1559     {
1560     STRLEN len;
1561     const char *ptr = SvPV(ST(1), len);
1562     if (!ptr) {
1563     SWIG_croak("Undefined variable in argument 2 of StrVector_push.");
1564     } else {
1565     arg2 = std::string(ptr, len);
1566     }
1567     }
1568     {
1569     try {
1570     (arg1)->push_back(arg2);
1571    
1572     } catch (const char *msg) {
1573     SWIG_exception(SWIG_RuntimeError, msg);
1574     }
1575     }
1576    
1577     XSRETURN(argvi);
1578     fail:
1579     ;
1580     }
1581     croak(Nullch);
1582     }
1583    
1584    
1585     XS(_wrap_StrVector_pop) {
1586     {
1587     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1588     std::string result;
1589     int argvi = 0;
1590     dXSARGS;
1591    
1592     if ((items < 1) || (items > 1)) {
1593     SWIG_croak("Usage: StrVector_pop(self);");
1594     }
1595     {
1596     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1597     SWIG_croak("Type error in argument 1 of StrVector_pop. Expected _p_std__vectorTstd__string_t");
1598     }
1599     }
1600     {
1601     try {
1602     result = std_vector_Sl_std_string_Sg__pop(arg1);
1603    
1604     } catch (std::out_of_range& e) {
1605     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1606     }
1607     }
1608     {
1609     if (argvi >= items) EXTEND(sp, 1); // bump stack ptr, if needed
1610     char *data = const_cast<char*>((&result)->data());
1611     sv_setpvn(ST(argvi) = sv_newmortal(), data, (&result)->size());
1612     ++argvi;
1613     }
1614     XSRETURN(argvi);
1615     fail:
1616     ;
1617     }
1618     croak(Nullch);
1619     }
1620    
1621    
1622     XS(_wrap_StrVector_get) {
1623     {
1624     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1625     int arg2 ;
1626     std::string result;
1627     int argvi = 0;
1628     dXSARGS;
1629    
1630     if ((items < 2) || (items > 2)) {
1631     SWIG_croak("Usage: StrVector_get(self,i);");
1632     }
1633     {
1634     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1635     SWIG_croak("Type error in argument 1 of StrVector_get. Expected _p_std__vectorTstd__string_t");
1636     }
1637     }
1638     arg2 = (int) SvIV(ST(1));
1639     {
1640     try {
1641     result = std_vector_Sl_std_string_Sg__get(arg1,arg2);
1642    
1643     } catch (std::out_of_range& e) {
1644     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1645     }
1646     }
1647     {
1648     if (argvi >= items) EXTEND(sp, 1); // bump stack ptr, if needed
1649     char *data = const_cast<char*>((&result)->data());
1650     sv_setpvn(ST(argvi) = sv_newmortal(), data, (&result)->size());
1651     ++argvi;
1652     }
1653     XSRETURN(argvi);
1654     fail:
1655     ;
1656     }
1657     croak(Nullch);
1658     }
1659    
1660    
1661     XS(_wrap_StrVector_set) {
1662     {
1663     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1664     int arg2 ;
1665     std::string arg3 ;
1666     int argvi = 0;
1667     dXSARGS;
1668    
1669     if ((items < 3) || (items > 3)) {
1670     SWIG_croak("Usage: StrVector_set(self,i,x);");
1671     }
1672     {
1673     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1674     SWIG_croak("Type error in argument 1 of StrVector_set. Expected _p_std__vectorTstd__string_t");
1675     }
1676     }
1677     arg2 = (int) SvIV(ST(1));
1678     {
1679     STRLEN len;
1680     const char *ptr = SvPV(ST(2), len);
1681     if (!ptr) {
1682     SWIG_croak("Undefined variable in argument 3 of StrVector_set.");
1683     } else {
1684     arg3 = std::string(ptr, len);
1685     }
1686     }
1687     {
1688     try {
1689     std_vector_Sl_std_string_Sg__set(arg1,arg2,arg3);
1690    
1691     } catch (std::out_of_range& e) {
1692     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1693     }
1694     }
1695    
1696     XSRETURN(argvi);
1697     fail:
1698     ;
1699     }
1700     croak(Nullch);
1701     }
1702    
1703    
1704     XS(_wrap_delete_StrVector) {
1705     {
1706     std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1707     int argvi = 0;
1708     dXSARGS;
1709    
1710     if ((items < 1) || (items > 1)) {
1711     SWIG_croak("Usage: delete_StrVector(self);");
1712     }
1713     {
1714     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,0) < 0) {
1715     SWIG_croak("Type error in argument 1 of delete_StrVector. Expected _p_std__vectorTstd__string_t");
1716     }
1717     }
1718     {
1719     try {
1720     delete arg1;
1721    
1722     } catch (const char *msg) {
1723     SWIG_exception(SWIG_RuntimeError, msg);
1724     }
1725     }
1726    
1727     XSRETURN(argvi);
1728     fail:
1729     ;
1730     }
1731     croak(Nullch);
1732     }
1733    
1734    
1735     XS(_wrap_new_IntVector__SWIG_0) {
1736     {
1737     unsigned int arg1 ;
1738     std::vector<int > *result;
1739     int argvi = 0;
1740     dXSARGS;
1741    
1742     if ((items < 1) || (items > 1)) {
1743     SWIG_croak("Usage: new_IntVector(size);");
1744     }
1745     arg1 = (unsigned int) SvUV(ST(0));
1746     {
1747     try {
1748     result = (std::vector<int > *)new std::vector<int >(arg1);
1749    
1750     } catch (const char *msg) {
1751     SWIG_exception(SWIG_RuntimeError, msg);
1752     }
1753     }
1754     ST(argvi) = sv_newmortal();
1755     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
1756     XSRETURN(argvi);
1757     fail:
1758     ;
1759     }
1760     croak(Nullch);
1761     }
1762    
1763    
1764     XS(_wrap_new_IntVector__SWIG_1) {
1765     {
1766     std::vector<int > *result;
1767     int argvi = 0;
1768     dXSARGS;
1769    
1770     if ((items < 0) || (items > 0)) {
1771     SWIG_croak("Usage: new_IntVector();");
1772     }
1773     {
1774     try {
1775     result = (std::vector<int > *)new std::vector<int >();
1776    
1777     } catch (const char *msg) {
1778     SWIG_exception(SWIG_RuntimeError, msg);
1779     }
1780     }
1781     ST(argvi) = sv_newmortal();
1782     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|0);
1783     XSRETURN(argvi);
1784     fail:
1785     ;
1786     }
1787     croak(Nullch);
1788     }
1789    
1790    
1791     XS(_wrap_new_IntVector__SWIG_2) {
1792     {
1793     unsigned int arg1 ;
1794     int arg2 ;
1795     std::vector<int > *result;
1796     int argvi = 0;
1797     dXSARGS;
1798    
1799     if ((items < 2) || (items > 2)) {
1800     SWIG_croak("Usage: new_IntVector(size,value);");
1801     }
1802     arg1 = (unsigned int) SvUV(ST(0));
1803     arg2 = (int) SvIV(ST(1));
1804     {
1805     try {
1806     result = (std::vector<int > *)new std::vector<int >(arg1,arg2);
1807    
1808     } catch (const char *msg) {
1809     SWIG_exception(SWIG_RuntimeError, msg);
1810     }
1811     }
1812     ST(argvi) = sv_newmortal();
1813     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
1814     XSRETURN(argvi);
1815     fail:
1816     ;
1817     }
1818     croak(Nullch);
1819     }
1820    
1821    
1822     XS(_wrap_new_IntVector__SWIG_3) {
1823     {
1824     std::vector<int > *arg1 = 0 ;
1825     std::vector<int > *result;
1826     std::vector<int > temp1 ;
1827     std::vector<int > *v1 ;
1828     int argvi = 0;
1829     dXSARGS;
1830    
1831     if ((items < 1) || (items > 1)) {
1832     SWIG_croak("Usage: new_IntVector(std::vector<int > const &);");
1833     }
1834     {
1835     if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1836     SWIGTYPE_p_std__vectorTint_t,1) != -1) {
1837     arg1 = v1;
1838     } else if (SvROK(ST(0))) {
1839     AV *av = (AV *)SvRV(ST(0));
1840     if (SvTYPE(av) != SVt_PVAV)
1841     SWIG_croak("Type error in argument 1 of new_IntVector. "
1842     "Expected an array of ""int");
1843     SV **tv;
1844     I32 len = av_len(av) + 1;
1845     int* obj;
1846     for (int i=0; i<len; i++) {
1847     tv = av_fetch(av, i, 0);
1848     if (SvIOK(*tv)) {
1849     temp1.push_back(SvIVX(*tv));
1850     } else {
1851     SWIG_croak("Type error in argument 1 of "
1852     "new_IntVector. "
1853     "Expected an array of ""int");
1854     }
1855     }
1856     arg1 = &temp1;
1857     } else {
1858     SWIG_croak("Type error in argument 1 of new_IntVector. "
1859     "Expected an array of ""int");
1860     }
1861     }
1862     {
1863     try {
1864     result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
1865    
1866     } catch (const char *msg) {
1867     SWIG_exception(SWIG_RuntimeError, msg);
1868     }
1869     }
1870     ST(argvi) = sv_newmortal();
1871     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|SWIG_OWNER);
1872     XSRETURN(argvi);
1873     fail:
1874     ;
1875     }
1876     croak(Nullch);
1877     }
1878    
1879    
1880     XS(_wrap_new_IntVector) {
1881     dXSARGS;
1882    
1883     if (items == 0) {
1884     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_1); return;
1885     }
1886     if (items == 1) {
1887     int _v;
1888     {
1889     _v = SvIOK(ST(0)) ? 1 : 0;
1890     }
1891     if (_v) {
1892     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_0); return;
1893     }
1894     }
1895     if (items == 1) {
1896     int _v;
1897     {
1898     {
1899     /* wrapped vector? */
1900     std::vector<int >* v;
1901     if (SWIG_ConvertPtr(ST(0),(void **) &v,
1902     SWIGTYPE_p_std__vectorTint_t,0) != -1) {
1903     _v = 1;
1904     } else if (SvROK(ST(0))) {
1905     /* native sequence? */
1906     AV *av = (AV *)SvRV(ST(0));
1907     if (SvTYPE(av) == SVt_PVAV) {
1908     SV **tv;
1909     I32 len = av_len(av) + 1;
1910     if (len == 0) {
1911     /* an empty sequence can be of any type */
1912     _v = 1;
1913     } else {
1914     /* check the first element only */
1915     tv = av_fetch(av, 0, 0);
1916     if (SvIOK(*tv))
1917     _v = 1;
1918     else
1919     _v = 0;
1920     }
1921     }
1922     } else {
1923     _v = 0;
1924     }
1925     }
1926     }
1927     if (_v) {
1928     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_3); return;
1929     }
1930     }
1931     if (items == 2) {
1932     int _v;
1933     {
1934     _v = SvIOK(ST(0)) ? 1 : 0;
1935     }
1936     if (_v) {
1937     {
1938     _v = SvIOK(ST(1)) ? 1 : 0;
1939     }
1940     if (_v) {
1941     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_IntVector__SWIG_2); return;
1942     }
1943     }
1944     }
1945    
1946     croak("No matching function for overloaded 'new_IntVector'");
1947     XSRETURN(0);
1948     }
1949    
1950    
1951     XS(_wrap_IntVector_size) {
1952     {
1953     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
1954     unsigned int result;
1955     std::vector<int > temp1 ;
1956     std::vector<int > *v1 ;
1957     int argvi = 0;
1958     dXSARGS;
1959    
1960     if ((items < 1) || (items > 1)) {
1961     SWIG_croak("Usage: IntVector_size(self);");
1962     }
1963     {
1964     if (SWIG_ConvertPtr(ST(0),(void **) &v1,
1965     SWIGTYPE_p_std__vectorTint_t,1) != -1) {
1966     arg1 = v1;
1967     } else if (SvROK(ST(0))) {
1968     AV *av = (AV *)SvRV(ST(0));
1969     if (SvTYPE(av) != SVt_PVAV)
1970     SWIG_croak("Type error in argument 1 of IntVector_size. "
1971     "Expected an array of ""int");
1972     SV **tv;
1973     I32 len = av_len(av) + 1;
1974     int* obj;
1975     for (int i=0; i<len; i++) {
1976     tv = av_fetch(av, i, 0);
1977     if (SvIOK(*tv)) {
1978     temp1.push_back(SvIVX(*tv));
1979     } else {
1980     SWIG_croak("Type error in argument 1 of "
1981     "IntVector_size. "
1982     "Expected an array of ""int");
1983     }
1984     }
1985     arg1 = &temp1;
1986     } else {
1987     SWIG_croak("Type error in argument 1 of IntVector_size. "
1988     "Expected an array of ""int");
1989     }
1990     }
1991     {
1992     try {
1993     result = (unsigned int)((std::vector<int > const *)arg1)->size();
1994    
1995     } catch (const char *msg) {
1996     SWIG_exception(SWIG_RuntimeError, msg);
1997     }
1998     }
1999     ST(argvi) = sv_newmortal();
2000     sv_setuv(ST(argvi++), (UV) result);
2001     XSRETURN(argvi);
2002     fail:
2003     ;
2004     }
2005     croak(Nullch);
2006     }
2007    
2008    
2009     XS(_wrap_IntVector_empty) {
2010     {
2011     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2012     bool result;
2013     std::vector<int > temp1 ;
2014     std::vector<int > *v1 ;
2015     int argvi = 0;
2016     dXSARGS;
2017    
2018     if ((items < 1) || (items > 1)) {
2019     SWIG_croak("Usage: IntVector_empty(self);");
2020     }
2021     {
2022     if (SWIG_ConvertPtr(ST(0),(void **) &v1,
2023     SWIGTYPE_p_std__vectorTint_t,1) != -1) {
2024     arg1 = v1;
2025     } else if (SvROK(ST(0))) {
2026     AV *av = (AV *)SvRV(ST(0));
2027     if (SvTYPE(av) != SVt_PVAV)
2028     SWIG_croak("Type error in argument 1 of IntVector_empty. "
2029     "Expected an array of ""int");
2030     SV **tv;
2031     I32 len = av_len(av) + 1;
2032     int* obj;
2033     for (int i=0; i<len; i++) {
2034     tv = av_fetch(av, i, 0);
2035     if (SvIOK(*tv)) {
2036     temp1.push_back(SvIVX(*tv));
2037     } else {
2038     SWIG_croak("Type error in argument 1 of "
2039     "IntVector_empty. "
2040     "Expected an array of ""int");
2041     }
2042     }
2043     arg1 = &temp1;
2044     } else {
2045     SWIG_croak("Type error in argument 1 of IntVector_empty. "
2046     "Expected an array of ""int");
2047     }
2048     }
2049     {
2050     try {
2051     result = (bool)((std::vector<int > const *)arg1)->empty();
2052    
2053     } catch (const char *msg) {
2054     SWIG_exception(SWIG_RuntimeError, msg);
2055     }
2056     }
2057     ST(argvi) = sv_newmortal();
2058     sv_setiv(ST(argvi++), (IV) result);
2059     XSRETURN(argvi);
2060     fail:
2061     ;
2062     }
2063     croak(Nullch);
2064     }
2065    
2066    
2067     XS(_wrap_IntVector_clear) {
2068     {
2069     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2070     int argvi = 0;
2071     dXSARGS;
2072    
2073     if ((items < 1) || (items > 1)) {
2074     SWIG_croak("Usage: IntVector_clear(self);");
2075     }
2076     {
2077     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2078     SWIG_croak("Type error in argument 1 of IntVector_clear. Expected _p_std__vectorTint_t");
2079     }
2080     }
2081     {
2082     try {
2083     (arg1)->clear();
2084    
2085     } catch (const char *msg) {
2086     SWIG_exception(SWIG_RuntimeError, msg);
2087     }
2088     }
2089    
2090     XSRETURN(argvi);
2091     fail:
2092     ;
2093     }
2094     croak(Nullch);
2095     }
2096    
2097    
2098     XS(_wrap_IntVector_push) {
2099     {
2100     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2101     int arg2 ;
2102     int argvi = 0;
2103     dXSARGS;
2104    
2105     if ((items < 2) || (items > 2)) {
2106     SWIG_croak("Usage: IntVector_push(self,x);");
2107     }
2108     {
2109     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2110     SWIG_croak("Type error in argument 1 of IntVector_push. Expected _p_std__vectorTint_t");
2111     }
2112     }
2113     arg2 = (int) SvIV(ST(1));
2114     {
2115     try {
2116     (arg1)->push_back(arg2);
2117    
2118     } catch (const char *msg) {
2119     SWIG_exception(SWIG_RuntimeError, msg);
2120     }
2121     }
2122    
2123     XSRETURN(argvi);
2124     fail:
2125     ;
2126     }
2127     croak(Nullch);
2128     }
2129    
2130    
2131     XS(_wrap_IntVector_pop) {
2132     {
2133     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2134     int result;
2135     int argvi = 0;
2136     dXSARGS;
2137    
2138     if ((items < 1) || (items > 1)) {
2139     SWIG_croak("Usage: IntVector_pop(self);");
2140     }
2141     {
2142     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2143     SWIG_croak("Type error in argument 1 of IntVector_pop. Expected _p_std__vectorTint_t");
2144     }
2145     }
2146     {
2147     try {
2148     result = (int)std_vector_Sl_int_Sg__pop(arg1);
2149    
2150     } catch (std::out_of_range& e) {
2151     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2152     }
2153     }
2154     ST(argvi) = sv_newmortal();
2155     sv_setiv(ST(argvi++), (IV) result);
2156     XSRETURN(argvi);
2157     fail:
2158     ;
2159     }
2160     croak(Nullch);
2161     }
2162    
2163    
2164     XS(_wrap_IntVector_get) {
2165     {
2166     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2167     int arg2 ;
2168     int result;
2169     int argvi = 0;
2170     dXSARGS;
2171    
2172     if ((items < 2) || (items > 2)) {
2173     SWIG_croak("Usage: IntVector_get(self,i);");
2174     }
2175     {
2176     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2177     SWIG_croak("Type error in argument 1 of IntVector_get. Expected _p_std__vectorTint_t");
2178     }
2179     }
2180     arg2 = (int) SvIV(ST(1));
2181     {
2182     try {
2183     result = (int)std_vector_Sl_int_Sg__get(arg1,arg2);
2184    
2185     } catch (std::out_of_range& e) {
2186     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2187     }
2188     }
2189     ST(argvi) = sv_newmortal();
2190     sv_setiv(ST(argvi++), (IV) result);
2191     XSRETURN(argvi);
2192     fail:
2193     ;
2194     }
2195     croak(Nullch);
2196     }
2197    
2198    
2199     XS(_wrap_IntVector_set) {
2200     {
2201     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2202     int arg2 ;
2203     int arg3 ;
2204     int argvi = 0;
2205     dXSARGS;
2206    
2207     if ((items < 3) || (items > 3)) {
2208     SWIG_croak("Usage: IntVector_set(self,i,x);");
2209     }
2210     {
2211     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2212     SWIG_croak("Type error in argument 1 of IntVector_set. Expected _p_std__vectorTint_t");
2213     }
2214     }
2215     arg2 = (int) SvIV(ST(1));
2216     arg3 = (int) SvIV(ST(2));
2217     {
2218     try {
2219     std_vector_Sl_int_Sg__set(arg1,arg2,arg3);
2220    
2221     } catch (std::out_of_range& e) {
2222     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2223     }
2224     }
2225    
2226     XSRETURN(argvi);
2227     fail:
2228     ;
2229     }
2230     croak(Nullch);
2231     }
2232    
2233    
2234     XS(_wrap_delete_IntVector) {
2235     {
2236     std::vector<int > *arg1 = (std::vector<int > *) 0 ;
2237     int argvi = 0;
2238     dXSARGS;
2239    
2240     if ((items < 1) || (items > 1)) {
2241     SWIG_croak("Usage: delete_IntVector(self);");
2242     }
2243     {
2244     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__vectorTint_t,0) < 0) {
2245     SWIG_croak("Type error in argument 1 of delete_IntVector. Expected _p_std__vectorTint_t");
2246     }
2247     }
2248     {
2249     try {
2250     delete arg1;
2251    
2252     } catch (const char *msg) {
2253     SWIG_exception(SWIG_RuntimeError, msg);
2254     }
2255     }
2256    
2257     XSRETURN(argvi);
2258     fail:
2259     ;
2260     }
2261     croak(Nullch);
2262     }
2263    
2264    
2265     XS(_wrap_new_StrStrMap__SWIG_0) {
2266     {
2267     std::map<std::string,std::string > *result;
2268     int argvi = 0;
2269     dXSARGS;
2270    
2271     if ((items < 0) || (items > 0)) {
2272     SWIG_croak("Usage: new_StrStrMap();");
2273     }
2274     {
2275     try {
2276     result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
2277    
2278     } catch (const char *msg) {
2279     SWIG_exception(SWIG_RuntimeError, msg);
2280     }
2281     }
2282     ST(argvi) = sv_newmortal();
2283     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|SWIG_OWNER);
2284     XSRETURN(argvi);
2285     fail:
2286     ;
2287     }
2288     croak(Nullch);
2289     }
2290    
2291    
2292     XS(_wrap_new_StrStrMap__SWIG_1) {
2293     {
2294     std::map<std::string,std::string > *arg1 = 0 ;
2295     std::map<std::string,std::string > *result;
2296     int argvi = 0;
2297     dXSARGS;
2298    
2299     if ((items < 1) || (items > 1)) {
2300     SWIG_croak("Usage: new_StrStrMap(std::map<std::string,std::string > const &);");
2301     }
2302     {
2303     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2304     SWIG_croak("Type error in argument 1 of new_StrStrMap. Expected _p_std__mapTstd__string_std__string_t");
2305     }
2306     }
2307     {
2308     try {
2309     result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
2310    
2311     } catch (const char *msg) {
2312     SWIG_exception(SWIG_RuntimeError, msg);
2313     }
2314     }
2315     ST(argvi) = sv_newmortal();
2316     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|SWIG_OWNER);
2317     XSRETURN(argvi);
2318     fail:
2319     ;
2320     }
2321     croak(Nullch);
2322     }
2323    
2324    
2325     XS(_wrap_new_StrStrMap) {
2326     dXSARGS;
2327    
2328     if (items == 0) {
2329     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrStrMap__SWIG_0); return;
2330     }
2331     if (items == 1) {
2332     int _v;
2333     {
2334     void *tmp;
2335     if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
2336     _v = 0;
2337     } else {
2338     _v = 1;
2339     }
2340     }
2341     if (_v) {
2342     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_StrStrMap__SWIG_1); return;
2343     }
2344     }
2345    
2346     croak("No matching function for overloaded 'new_StrStrMap'");
2347     XSRETURN(0);
2348     }
2349    
2350    
2351     XS(_wrap_StrStrMap_size) {
2352     {
2353     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2354     unsigned int result;
2355     int argvi = 0;
2356     dXSARGS;
2357    
2358     if ((items < 1) || (items > 1)) {
2359     SWIG_croak("Usage: StrStrMap_size(self);");
2360     }
2361     {
2362     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2363     SWIG_croak("Type error in argument 1 of StrStrMap_size. Expected _p_std__mapTstd__string_std__string_t");
2364     }
2365     }
2366     {
2367     try {
2368     result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
2369    
2370     } catch (const char *msg) {
2371     SWIG_exception(SWIG_RuntimeError, msg);
2372     }
2373     }
2374     ST(argvi) = sv_newmortal();
2375     sv_setuv(ST(argvi++), (UV) result);
2376     XSRETURN(argvi);
2377     fail:
2378     ;
2379     }
2380     croak(Nullch);
2381     }
2382    
2383    
2384     XS(_wrap_StrStrMap_empty) {
2385     {
2386     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2387     bool result;
2388     int argvi = 0;
2389     dXSARGS;
2390    
2391     if ((items < 1) || (items > 1)) {
2392     SWIG_croak("Usage: StrStrMap_empty(self);");
2393     }
2394     {
2395     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2396     SWIG_croak("Type error in argument 1 of StrStrMap_empty. Expected _p_std__mapTstd__string_std__string_t");
2397     }
2398     }
2399     {
2400     try {
2401     result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
2402    
2403     } catch (const char *msg) {
2404     SWIG_exception(SWIG_RuntimeError, msg);
2405     }
2406     }
2407     ST(argvi) = sv_newmortal();
2408     sv_setiv(ST(argvi++), (IV) result);
2409     XSRETURN(argvi);
2410     fail:
2411     ;
2412     }
2413     croak(Nullch);
2414     }
2415    
2416    
2417     XS(_wrap_StrStrMap_clear) {
2418     {
2419     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2420     int argvi = 0;
2421     dXSARGS;
2422    
2423     if ((items < 1) || (items > 1)) {
2424     SWIG_croak("Usage: StrStrMap_clear(self);");
2425     }
2426     {
2427     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2428     SWIG_croak("Type error in argument 1 of StrStrMap_clear. Expected _p_std__mapTstd__string_std__string_t");
2429     }
2430     }
2431     {
2432     try {
2433     (arg1)->clear();
2434    
2435     } catch (const char *msg) {
2436     SWIG_exception(SWIG_RuntimeError, msg);
2437     }
2438     }
2439    
2440     XSRETURN(argvi);
2441     fail:
2442     ;
2443     }
2444     croak(Nullch);
2445     }
2446    
2447    
2448     XS(_wrap_StrStrMap_get) {
2449     {
2450     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2451     std::string *arg2 = 0 ;
2452     std::string *result;
2453     std::string temp2 ;
2454     int argvi = 0;
2455     dXSARGS;
2456    
2457     if ((items < 2) || (items > 2)) {
2458     SWIG_croak("Usage: StrStrMap_get(self,key);");
2459     }
2460     {
2461     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2462     SWIG_croak("Type error in argument 1 of StrStrMap_get. Expected _p_std__mapTstd__string_std__string_t");
2463     }
2464     }
2465     {
2466     STRLEN len;
2467     const char *ptr = SvPV(ST(1), len);
2468     if (!ptr) {
2469     SWIG_croak("Undefined variable in argument 2 of StrStrMap_get.");
2470     } else {
2471     temp2.assign(ptr, len);
2472     arg2 = &temp2;
2473     }
2474     }
2475     {
2476     try {
2477     {
2478     std::string &_result_ref = std_map_Sl_std_string_Sc_std_string_Sg__get(arg1,(std::string const &)*arg2);
2479     result = (std::string *) &_result_ref;
2480     }
2481    
2482     } catch (std::out_of_range& e) {
2483     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2484     }
2485     }
2486     ST(argvi) = sv_newmortal();
2487     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__string, 0|0);
2488     XSRETURN(argvi);
2489     fail:
2490     ;
2491     }
2492     croak(Nullch);
2493     }
2494    
2495    
2496     XS(_wrap_StrStrMap_set) {
2497     {
2498     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2499     std::string *arg2 = 0 ;
2500     std::string *arg3 = 0 ;
2501     std::string temp2 ;
2502     std::string temp3 ;
2503     int argvi = 0;
2504     dXSARGS;
2505    
2506     if ((items < 3) || (items > 3)) {
2507     SWIG_croak("Usage: StrStrMap_set(self,key,x);");
2508     }
2509     {
2510     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2511     SWIG_croak("Type error in argument 1 of StrStrMap_set. Expected _p_std__mapTstd__string_std__string_t");
2512     }
2513     }
2514     {
2515     STRLEN len;
2516     const char *ptr = SvPV(ST(1), len);
2517     if (!ptr) {
2518     SWIG_croak("Undefined variable in argument 2 of StrStrMap_set.");
2519     } else {
2520     temp2.assign(ptr, len);
2521     arg2 = &temp2;
2522     }
2523     }
2524     {
2525     STRLEN len;
2526     const char *ptr = SvPV(ST(2), len);
2527     if (!ptr) {
2528     SWIG_croak("Undefined variable in argument 3 of StrStrMap_set.");
2529     } else {
2530     temp3.assign(ptr, len);
2531     arg3 = &temp3;
2532     }
2533     }
2534     {
2535     try {
2536     std_map_Sl_std_string_Sc_std_string_Sg__set(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
2537    
2538     } catch (const char *msg) {
2539     SWIG_exception(SWIG_RuntimeError, msg);
2540     }
2541     }
2542    
2543     XSRETURN(argvi);
2544     fail:
2545     ;
2546     }
2547     croak(Nullch);
2548     }
2549    
2550    
2551     XS(_wrap_StrStrMap_del) {
2552     {
2553     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2554     std::string *arg2 = 0 ;
2555     std::string temp2 ;
2556     int argvi = 0;
2557     dXSARGS;
2558    
2559     if ((items < 2) || (items > 2)) {
2560     SWIG_croak("Usage: StrStrMap_del(self,key);");
2561     }
2562     {
2563     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2564     SWIG_croak("Type error in argument 1 of StrStrMap_del. Expected _p_std__mapTstd__string_std__string_t");
2565     }
2566     }
2567     {
2568     STRLEN len;
2569     const char *ptr = SvPV(ST(1), len);
2570     if (!ptr) {
2571     SWIG_croak("Undefined variable in argument 2 of StrStrMap_del.");
2572     } else {
2573     temp2.assign(ptr, len);
2574     arg2 = &temp2;
2575     }
2576     }
2577     {
2578     try {
2579     std_map_Sl_std_string_Sc_std_string_Sg__del(arg1,(std::string const &)*arg2);
2580    
2581     } catch (std::out_of_range& e) {
2582     SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2583     }
2584     }
2585    
2586     XSRETURN(argvi);
2587     fail:
2588     ;
2589     }
2590     croak(Nullch);
2591     }
2592    
2593    
2594     XS(_wrap_StrStrMap_has_key) {
2595     {
2596     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2597     std::string *arg2 = 0 ;
2598     bool result;
2599     std::string temp2 ;
2600     int argvi = 0;
2601     dXSARGS;
2602    
2603     if ((items < 2) || (items > 2)) {
2604     SWIG_croak("Usage: StrStrMap_has_key(self,key);");
2605     }
2606     {
2607     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2608     SWIG_croak("Type error in argument 1 of StrStrMap_has_key. Expected _p_std__mapTstd__string_std__string_t");
2609     }
2610     }
2611     {
2612     STRLEN len;
2613     const char *ptr = SvPV(ST(1), len);
2614     if (!ptr) {
2615     SWIG_croak("Undefined variable in argument 2 of StrStrMap_has_key.");
2616     } else {
2617     temp2.assign(ptr, len);
2618     arg2 = &temp2;
2619     }
2620     }
2621     {
2622     try {
2623     result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key(arg1,(std::string const &)*arg2);
2624    
2625     } catch (const char *msg) {
2626     SWIG_exception(SWIG_RuntimeError, msg);
2627     }
2628     }
2629     ST(argvi) = sv_newmortal();
2630     sv_setiv(ST(argvi++), (IV) result);
2631     XSRETURN(argvi);
2632     fail:
2633     ;
2634     }
2635     croak(Nullch);
2636     }
2637    
2638    
2639     XS(_wrap_delete_StrStrMap) {
2640     {
2641     std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
2642     int argvi = 0;
2643     dXSARGS;
2644    
2645     if ((items < 1) || (items > 1)) {
2646     SWIG_croak("Usage: delete_StrStrMap(self);");
2647     }
2648     {
2649     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,0) < 0) {
2650     SWIG_croak("Type error in argument 1 of delete_StrStrMap. Expected _p_std__mapTstd__string_std__string_t");
2651     }
2652     }
2653     {
2654     try {
2655     delete arg1;
2656    
2657     } catch (const char *msg) {
2658     SWIG_exception(SWIG_RuntimeError, msg);
2659     }
2660     }
2661    
2662     XSRETURN(argvi);
2663     fail:
2664     ;
2665     }
2666     croak(Nullch);
2667     }
2668    
2669    
2670     XS(_wrap_Condition_cond_set) {
2671     {
2672     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2673     ESTCOND *arg2 = (ESTCOND *) 0 ;
2674     int argvi = 0;
2675     dXSARGS;
2676    
2677     if ((items < 2) || (items > 2)) {
2678     SWIG_croak("Usage: Condition_cond_set(self,cond);");
2679     }
2680     {
2681     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2682     SWIG_croak("Type error in argument 1 of Condition_cond_set. Expected _p_estraier__Condition");
2683     }
2684     }
2685     {
2686     if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ESTCOND,0) < 0) {
2687     SWIG_croak("Type error in argument 2 of Condition_cond_set. Expected _p_ESTCOND");
2688     }
2689     }
2690     if (arg1) (arg1)->cond = arg2;
2691    
2692    
2693     XSRETURN(argvi);
2694     fail:
2695     ;
2696     }
2697     croak(Nullch);
2698     }
2699    
2700    
2701     XS(_wrap_Condition_cond_get) {
2702     {
2703     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2704     ESTCOND *result;
2705     int argvi = 0;
2706     dXSARGS;
2707    
2708     if ((items < 1) || (items > 1)) {
2709     SWIG_croak("Usage: Condition_cond_get(self);");
2710     }
2711     {
2712     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2713     SWIG_croak("Type error in argument 1 of Condition_cond_get. Expected _p_estraier__Condition");
2714     }
2715     }
2716     result = (ESTCOND *) ((arg1)->cond);
2717    
2718     ST(argvi) = sv_newmortal();
2719     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ESTCOND, 0|0);
2720     XSRETURN(argvi);
2721     fail:
2722     ;
2723     }
2724     croak(Nullch);
2725     }
2726    
2727    
2728     XS(_wrap_new_Condition) {
2729     {
2730     estraier::Condition *result;
2731     int argvi = 0;
2732     dXSARGS;
2733    
2734     if ((items < 0) || (items > 0)) {
2735     SWIG_croak("Usage: new_Condition();");
2736     }
2737     {
2738     try {
2739     result = (estraier::Condition *)new estraier::Condition();
2740    
2741     } catch (const char *msg) {
2742     SWIG_exception(SWIG_RuntimeError, msg);
2743     }
2744     }
2745     ST(argvi) = sv_newmortal();
2746     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Condition, SWIG_SHADOW|SWIG_OWNER);
2747     XSRETURN(argvi);
2748     fail:
2749     ;
2750     }
2751     croak(Nullch);
2752     }
2753    
2754    
2755     XS(_wrap_delete_Condition) {
2756     {
2757     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2758     int argvi = 0;
2759     dXSARGS;
2760    
2761     if ((items < 1) || (items > 1)) {
2762     SWIG_croak("Usage: delete_Condition(self);");
2763     }
2764     {
2765     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2766     SWIG_croak("Type error in argument 1 of delete_Condition. Expected _p_estraier__Condition");
2767     }
2768     }
2769     {
2770     try {
2771     delete arg1;
2772    
2773     } catch (const char *msg) {
2774     SWIG_exception(SWIG_RuntimeError, msg);
2775     }
2776     }
2777    
2778     XSRETURN(argvi);
2779     fail:
2780     ;
2781     }
2782     croak(Nullch);
2783     }
2784    
2785    
2786     XS(_wrap_Condition_set_phrase) {
2787     {
2788     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2789     char *arg2 = (char *) 0 ;
2790     int argvi = 0;
2791     dXSARGS;
2792    
2793     if ((items < 2) || (items > 2)) {
2794     SWIG_croak("Usage: Condition_set_phrase(self,phrase);");
2795     }
2796     {
2797     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2798     SWIG_croak("Type error in argument 1 of Condition_set_phrase. Expected _p_estraier__Condition");
2799     }
2800     }
2801     if (!SvOK((SV*) ST(1))) arg2 = 0;
2802     else arg2 = (char *) SvPV(ST(1), PL_na);
2803     {
2804     try {
2805     (arg1)->set_phrase((char const *)arg2);
2806    
2807     } catch (const char *msg) {
2808     SWIG_exception(SWIG_RuntimeError, msg);
2809     }
2810     }
2811    
2812     XSRETURN(argvi);
2813     fail:
2814     ;
2815     }
2816     croak(Nullch);
2817     }
2818    
2819    
2820     XS(_wrap_Condition_add_attr) {
2821     {
2822     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2823     char *arg2 = (char *) 0 ;
2824     int argvi = 0;
2825     dXSARGS;
2826    
2827     if ((items < 2) || (items > 2)) {
2828     SWIG_croak("Usage: Condition_add_attr(self,expr);");
2829     }
2830     {
2831     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2832     SWIG_croak("Type error in argument 1 of Condition_add_attr. Expected _p_estraier__Condition");
2833     }
2834     }
2835     if (!SvOK((SV*) ST(1))) arg2 = 0;
2836     else arg2 = (char *) SvPV(ST(1), PL_na);
2837     {
2838     try {
2839     (arg1)->add_attr((char const *)arg2);
2840    
2841     } catch (const char *msg) {
2842     SWIG_exception(SWIG_RuntimeError, msg);
2843     }
2844     }
2845    
2846     XSRETURN(argvi);
2847     fail:
2848     ;
2849     }
2850     croak(Nullch);
2851     }
2852    
2853    
2854     XS(_wrap_Condition_set_order) {
2855     {
2856     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2857     char *arg2 = (char *) 0 ;
2858     int argvi = 0;
2859     dXSARGS;
2860    
2861     if ((items < 2) || (items > 2)) {
2862     SWIG_croak("Usage: Condition_set_order(self,expr);");
2863     }
2864     {
2865     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2866     SWIG_croak("Type error in argument 1 of Condition_set_order. Expected _p_estraier__Condition");
2867     }
2868     }
2869     if (!SvOK((SV*) ST(1))) arg2 = 0;
2870     else arg2 = (char *) SvPV(ST(1), PL_na);
2871     {
2872     try {
2873     (arg1)->set_order((char const *)arg2);
2874    
2875     } catch (const char *msg) {
2876     SWIG_exception(SWIG_RuntimeError, msg);
2877     }
2878     }
2879    
2880     XSRETURN(argvi);
2881     fail:
2882     ;
2883     }
2884     croak(Nullch);
2885     }
2886    
2887    
2888     XS(_wrap_Condition_set_max) {
2889     {
2890     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2891     int arg2 ;
2892     int argvi = 0;
2893     dXSARGS;
2894    
2895     if ((items < 2) || (items > 2)) {
2896     SWIG_croak("Usage: Condition_set_max(self,_max);");
2897     }
2898     {
2899     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2900     SWIG_croak("Type error in argument 1 of Condition_set_max. Expected _p_estraier__Condition");
2901     }
2902     }
2903     arg2 = (int) SvIV(ST(1));
2904     {
2905     try {
2906     (arg1)->set_max(arg2);
2907    
2908     } catch (const char *msg) {
2909     SWIG_exception(SWIG_RuntimeError, msg);
2910     }
2911     }
2912    
2913     XSRETURN(argvi);
2914     fail:
2915     ;
2916     }
2917     croak(Nullch);
2918     }
2919    
2920    
2921     XS(_wrap_Condition_set_options) {
2922     {
2923     estraier::Condition *arg1 = (estraier::Condition *) 0 ;
2924     int arg2 ;
2925     int argvi = 0;
2926     dXSARGS;
2927    
2928     if ((items < 2) || (items > 2)) {
2929     SWIG_croak("Usage: Condition_set_options(self,options);");
2930     }
2931     {
2932     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Condition,0) < 0) {
2933     SWIG_croak("Type error in argument 1 of Condition_set_options. Expected _p_estraier__Condition");
2934     }
2935     }
2936     arg2 = (int) SvIV(ST(1));
2937     {
2938     try {
2939     (arg1)->set_options(arg2);
2940    
2941     } catch (const char *msg) {
2942     SWIG_exception(SWIG_RuntimeError, msg);
2943     }
2944     }
2945    
2946     XSRETURN(argvi);
2947     fail:
2948     ;
2949     }
2950     croak(Nullch);
2951     }
2952    
2953    
2954     XS(_wrap_Document_doc_set) {
2955     {
2956     estraier::Document *arg1 = (estraier::Document *) 0 ;
2957     ESTDOC *arg2 = (ESTDOC *) 0 ;
2958     int argvi = 0;
2959     dXSARGS;
2960    
2961     if ((items < 2) || (items > 2)) {
2962     SWIG_croak("Usage: Document_doc_set(self,doc);");
2963     }
2964     {
2965     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
2966     SWIG_croak("Type error in argument 1 of Document_doc_set. Expected _p_estraier__Document");
2967     }
2968     }
2969     {
2970     if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ESTDOC,0) < 0) {
2971     SWIG_croak("Type error in argument 2 of Document_doc_set. Expected _p_ESTDOC");
2972     }
2973     }
2974     if (arg1) (arg1)->doc = arg2;
2975    
2976    
2977     XSRETURN(argvi);
2978     fail:
2979     ;
2980     }
2981     croak(Nullch);
2982     }
2983    
2984    
2985     XS(_wrap_Document_doc_get) {
2986     {
2987     estraier::Document *arg1 = (estraier::Document *) 0 ;
2988     ESTDOC *result;
2989     int argvi = 0;
2990     dXSARGS;
2991    
2992     if ((items < 1) || (items > 1)) {
2993     SWIG_croak("Usage: Document_doc_get(self);");
2994     }
2995     {
2996     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
2997     SWIG_croak("Type error in argument 1 of Document_doc_get. Expected _p_estraier__Document");
2998     }
2999     }
3000     result = (ESTDOC *) ((arg1)->doc);
3001    
3002     ST(argvi) = sv_newmortal();
3003     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ESTDOC, 0|0);
3004     XSRETURN(argvi);
3005     fail:
3006     ;
3007     }
3008     croak(Nullch);
3009     }
3010    
3011    
3012     XS(_wrap_new_Document__SWIG_0) {
3013     {
3014     estraier::Document *result;
3015     int argvi = 0;
3016     dXSARGS;
3017    
3018     if ((items < 0) || (items > 0)) {
3019     SWIG_croak("Usage: new_Document();");
3020     }
3021     {
3022     try {
3023     result = (estraier::Document *)new estraier::Document();
3024    
3025     } catch (const char *msg) {
3026     SWIG_exception(SWIG_RuntimeError, msg);
3027     }
3028     }
3029     ST(argvi) = sv_newmortal();
3030     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
3031     XSRETURN(argvi);
3032     fail:
3033     ;
3034     }
3035     croak(Nullch);
3036     }
3037    
3038    
3039     XS(_wrap_new_Document__SWIG_1) {
3040     {
3041     char *arg1 = (char *) 0 ;
3042     estraier::Document *result;
3043     int argvi = 0;
3044     dXSARGS;
3045    
3046     if ((items < 1) || (items > 1)) {
3047     SWIG_croak("Usage: new_Document(draft);");
3048     }
3049     if (!SvOK((SV*) ST(0))) arg1 = 0;
3050     else arg1 = (char *) SvPV(ST(0), PL_na);
3051     {
3052     try {
3053     result = (estraier::Document *)new estraier::Document((char const *)arg1);
3054    
3055     } catch (const char *msg) {
3056     SWIG_exception(SWIG_RuntimeError, msg);
3057     }
3058     }
3059     ST(argvi) = sv_newmortal();
3060     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
3061     XSRETURN(argvi);
3062     fail:
3063     ;
3064     }
3065     croak(Nullch);
3066     }
3067    
3068    
3069     XS(_wrap_new_Document__SWIG_2) {
3070     {
3071     ESTDOC *arg1 = (ESTDOC *) 0 ;
3072     estraier::Document *result;
3073     int argvi = 0;
3074     dXSARGS;
3075    
3076     if ((items < 1) || (items > 1)) {
3077     SWIG_croak("Usage: new_Document(_doc);");
3078     }
3079     {
3080     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ESTDOC,0) < 0) {
3081     SWIG_croak("Type error in argument 1 of new_Document. Expected _p_ESTDOC");
3082     }
3083     }
3084     {
3085     try {
3086     result = (estraier::Document *)new estraier::Document(arg1);
3087    
3088     } catch (const char *msg) {
3089     SWIG_exception(SWIG_RuntimeError, msg);
3090     }
3091     }
3092     ST(argvi) = sv_newmortal();
3093     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|SWIG_OWNER);
3094     XSRETURN(argvi);
3095     fail:
3096     ;
3097     }
3098     croak(Nullch);
3099     }
3100    
3101    
3102     XS(_wrap_new_Document) {
3103     dXSARGS;
3104    
3105     if (items == 0) {
3106     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_0); return;
3107     }
3108     if (items == 1) {
3109     int _v;
3110     {
3111     void *tmp;
3112     if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ESTDOC, 0) == -1) {
3113     _v = 0;
3114     } else {
3115     _v = 1;
3116     }
3117     }
3118     if (_v) {
3119     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_2); return;
3120     }
3121     }
3122     if (items == 1) {
3123     int _v;
3124     {
3125     _v = SvPOK(ST(0)) ? 1 : 0;
3126     }
3127     if (_v) {
3128     (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_new_Document__SWIG_1); return;
3129     }
3130     }
3131    
3132     croak("No matching function for overloaded 'new_Document'");
3133     XSRETURN(0);
3134     }
3135    
3136    
3137     XS(_wrap_delete_Document) {
3138     {
3139     estraier::Document *arg1 = (estraier::Document *) 0 ;
3140     int argvi = 0;
3141     dXSARGS;
3142    
3143     if ((items < 1) || (items > 1)) {
3144     SWIG_croak("Usage: delete_Document(self);");
3145     }
3146     {
3147     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3148     SWIG_croak("Type error in argument 1 of delete_Document. Expected _p_estraier__Document");
3149     }
3150     }
3151     {
3152     try {
3153     delete arg1;
3154    
3155     } catch (const char *msg) {
3156     SWIG_exception(SWIG_RuntimeError, msg);
3157     }
3158     }
3159    
3160     XSRETURN(argvi);
3161     fail:
3162     ;
3163     }
3164     croak(Nullch);
3165     }
3166    
3167    
3168     XS(_wrap_Document_add_attr) {
3169     {
3170     estraier::Document *arg1 = (estraier::Document *) 0 ;
3171     char *arg2 = (char *) 0 ;
3172     char *arg3 = (char *) 0 ;
3173     int argvi = 0;
3174     dXSARGS;
3175    
3176     if ((items < 3) || (items > 3)) {
3177     SWIG_croak("Usage: Document_add_attr(self,name,value);");
3178     }
3179     {
3180     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3181     SWIG_croak("Type error in argument 1 of Document_add_attr. Expected _p_estraier__Document");
3182     }
3183     }
3184     if (!SvOK((SV*) ST(1))) arg2 = 0;
3185     else arg2 = (char *) SvPV(ST(1), PL_na);
3186     if (!SvOK((SV*) ST(2))) arg3 = 0;
3187     else arg3 = (char *) SvPV(ST(2), PL_na);
3188     {
3189     try {
3190     (arg1)->add_attr((char const *)arg2,(char const *)arg3);
3191    
3192     } catch (const char *msg) {
3193     SWIG_exception(SWIG_RuntimeError, msg);
3194     }
3195     }
3196    
3197     XSRETURN(argvi);
3198     fail:
3199     ;
3200     }
3201     croak(Nullch);
3202     }
3203    
3204    
3205     XS(_wrap_Document_add_text) {
3206     {
3207     estraier::Document *arg1 = (estraier::Document *) 0 ;
3208     char *arg2 = (char *) 0 ;
3209     int argvi = 0;
3210     dXSARGS;
3211    
3212     if ((items < 2) || (items > 2)) {
3213     SWIG_croak("Usage: Document_add_text(self,text);");
3214     }
3215     {
3216     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3217     SWIG_croak("Type error in argument 1 of Document_add_text. Expected _p_estraier__Document");
3218     }
3219     }
3220     if (!SvOK((SV*) ST(1))) arg2 = 0;
3221     else arg2 = (char *) SvPV(ST(1), PL_na);
3222     {
3223     try {
3224     (arg1)->add_text((char const *)arg2);
3225    
3226     } catch (const char *msg) {
3227     SWIG_exception(SWIG_RuntimeError, msg);
3228     }
3229     }
3230    
3231     XSRETURN(argvi);
3232     fail:
3233     ;
3234     }
3235     croak(Nullch);
3236     }
3237    
3238    
3239     XS(_wrap_Document_add_hidden_text) {
3240     {
3241     estraier::Document *arg1 = (estraier::Document *) 0 ;
3242     char *arg2 = (char *) 0 ;
3243     int argvi = 0;
3244     dXSARGS;
3245    
3246     if ((items < 2) || (items > 2)) {
3247     SWIG_croak("Usage: Document_add_hidden_text(self,text);");
3248     }
3249     {
3250     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3251     SWIG_croak("Type error in argument 1 of Document_add_hidden_text. Expected _p_estraier__Document");
3252     }
3253     }
3254     if (!SvOK((SV*) ST(1))) arg2 = 0;
3255     else arg2 = (char *) SvPV(ST(1), PL_na);
3256     {
3257     try {
3258     (arg1)->add_hidden_text((char const *)arg2);
3259    
3260     } catch (const char *msg) {
3261     SWIG_exception(SWIG_RuntimeError, msg);
3262     }
3263     }
3264    
3265     XSRETURN(argvi);
3266     fail:
3267     ;
3268     }
3269     croak(Nullch);
3270     }
3271    
3272    
3273     XS(_wrap_Document_id) {
3274     {
3275     estraier::Document *arg1 = (estraier::Document *) 0 ;
3276     int result;
3277     int argvi = 0;
3278     dXSARGS;
3279    
3280     if ((items < 1) || (items > 1)) {
3281     SWIG_croak("Usage: Document_id(self);");
3282     }
3283     {
3284     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3285     SWIG_croak("Type error in argument 1 of Document_id. Expected _p_estraier__Document");
3286     }
3287     }
3288     {
3289     try {
3290     result = (int)(arg1)->id();
3291    
3292     } catch (const char *msg) {
3293     SWIG_exception(SWIG_RuntimeError, msg);
3294     }
3295     }
3296     ST(argvi) = sv_newmortal();
3297     sv_setiv(ST(argvi++), (IV) result);
3298     XSRETURN(argvi);
3299     fail:
3300     ;
3301     }
3302     croak(Nullch);
3303     }
3304    
3305    
3306     XS(_wrap_Document_attr_names) {
3307     {
3308     estraier::Document *arg1 = (estraier::Document *) 0 ;
3309     std::vector<std::string > *result;
3310     int argvi = 0;
3311     dXSARGS;
3312    
3313     if ((items < 1) || (items > 1)) {
3314     SWIG_croak("Usage: Document_attr_names(self);");
3315     }
3316     {
3317     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3318     SWIG_croak("Type error in argument 1 of Document_attr_names. Expected _p_estraier__Document");
3319     }
3320     }
3321     {
3322     try {
3323     result = (std::vector<std::string > *)(arg1)->attr_names();
3324    
3325     } catch (const char *msg) {
3326     SWIG_exception(SWIG_RuntimeError, msg);
3327     }
3328     }
3329     ST(argvi) = sv_newmortal();
3330     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
3331     XSRETURN(argvi);
3332     fail:
3333     ;
3334     }
3335     croak(Nullch);
3336     }
3337    
3338    
3339     XS(_wrap_Document_attr) {
3340     {
3341     estraier::Document *arg1 = (estraier::Document *) 0 ;
3342     char *arg2 = (char *) 0 ;
3343     char *result;
3344     int argvi = 0;
3345     dXSARGS;
3346    
3347     if ((items < 2) || (items > 2)) {
3348     SWIG_croak("Usage: Document_attr(self,name);");
3349     }
3350     {
3351     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3352     SWIG_croak("Type error in argument 1 of Document_attr. Expected _p_estraier__Document");
3353     }
3354     }
3355     if (!SvOK((SV*) ST(1))) arg2 = 0;
3356     else arg2 = (char *) SvPV(ST(1), PL_na);
3357     {
3358     try {
3359     result = (char *)(arg1)->attr((char const *)arg2);
3360    
3361     } catch (const char *msg) {
3362     SWIG_exception(SWIG_RuntimeError, msg);
3363     }
3364     }
3365     ST(argvi) = sv_newmortal();
3366     if (result) {
3367     sv_setpv((SV*)ST(argvi++), (char *) result);
3368     } else {
3369     sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3370     }
3371     XSRETURN(argvi);
3372     fail:
3373     ;
3374     }
3375     croak(Nullch);
3376     }
3377    
3378    
3379     XS(_wrap_Document_cat_texts) {
3380     {
3381     estraier::Document *arg1 = (estraier::Document *) 0 ;
3382     char *result;
3383     int argvi = 0;
3384     dXSARGS;
3385    
3386     if ((items < 1) || (items > 1)) {
3387     SWIG_croak("Usage: Document_cat_texts(self);");
3388     }
3389     {
3390     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3391     SWIG_croak("Type error in argument 1 of Document_cat_texts. Expected _p_estraier__Document");
3392     }
3393     }
3394     {
3395     try {
3396     result = (char *)(arg1)->cat_texts();
3397    
3398     } catch (const char *msg) {
3399     SWIG_exception(SWIG_RuntimeError, msg);
3400     }
3401     }
3402     ST(argvi) = sv_newmortal();
3403     if (result) {
3404     sv_setpv((SV*)ST(argvi++), (char *) result);
3405     } else {
3406     sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3407     }
3408     XSRETURN(argvi);
3409     fail:
3410     ;
3411     }
3412     croak(Nullch);
3413     }
3414    
3415    
3416     XS(_wrap_Document_texts) {
3417     {
3418     estraier::Document *arg1 = (estraier::Document *) 0 ;
3419     std::vector<std::string > *result;
3420     int argvi = 0;
3421     dXSARGS;
3422    
3423     if ((items < 1) || (items > 1)) {
3424     SWIG_croak("Usage: Document_texts(self);");
3425     }
3426     {
3427     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3428     SWIG_croak("Type error in argument 1 of Document_texts. Expected _p_estraier__Document");
3429     }
3430     }
3431     {
3432     try {
3433     result = (std::vector<std::string > *)(arg1)->texts();
3434    
3435     } catch (const char *msg) {
3436     SWIG_exception(SWIG_RuntimeError, msg);
3437     }
3438     }
3439     ST(argvi) = sv_newmortal();
3440     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTstd__string_t, SWIG_SHADOW|0);
3441     XSRETURN(argvi);
3442     fail:
3443     ;
3444     }
3445     croak(Nullch);
3446     }
3447    
3448    
3449     XS(_wrap_Document_dump_draft) {
3450     {
3451     estraier::Document *arg1 = (estraier::Document *) 0 ;
3452     char *result;
3453     int argvi = 0;
3454     dXSARGS;
3455    
3456     if ((items < 1) || (items > 1)) {
3457     SWIG_croak("Usage: Document_dump_draft(self);");
3458     }
3459     {
3460     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3461     SWIG_croak("Type error in argument 1 of Document_dump_draft. Expected _p_estraier__Document");
3462     }
3463     }
3464     {
3465     try {
3466     result = (char *)(arg1)->dump_draft();
3467    
3468     } catch (const char *msg) {
3469     SWIG_exception(SWIG_RuntimeError, msg);
3470     }
3471     }
3472     ST(argvi) = sv_newmortal();
3473     if (result) {
3474     sv_setpv((SV*)ST(argvi++), (char *) result);
3475     } else {
3476     sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3477     }
3478     XSRETURN(argvi);
3479     fail:
3480     ;
3481     }
3482     croak(Nullch);
3483     }
3484    
3485    
3486     XS(_wrap_Document_make_snippet) {
3487     {
3488     estraier::Document *arg1 = (estraier::Document *) 0 ;
3489     std::vector<std::string > arg2 ;
3490     int arg3 ;
3491     int arg4 ;
3492     int arg5 ;
3493     char *result;
3494     std::vector<std::string > *v2 ;
3495     int argvi = 0;
3496     dXSARGS;
3497    
3498     if ((items < 5) || (items > 5)) {
3499     SWIG_croak("Usage: Document_make_snippet(self,_words,wwidth,hwidth,awidth);");
3500     }
3501     {
3502     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Document,0) < 0) {
3503     SWIG_croak("Type error in argument 1 of Document_make_snippet. Expected _p_estraier__Document");
3504     }
3505     }
3506     {
3507     if (SWIG_ConvertPtr(ST(1),(void **) &v2,
3508     SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
3509     arg2 = *v2;
3510     } else if (SvROK(ST(1))) {
3511     AV *av = (AV *)SvRV(ST(1));
3512     if (SvTYPE(av) != SVt_PVAV)
3513     SWIG_croak("Type error in argument 2 of Document_make_snippet. "
3514     "Expected an array of ""std::string");
3515     SV **tv;
3516     I32 len = av_len(av) + 1;
3517     for (int i=0; i<len; i++) {
3518     tv = av_fetch(av, i, 0);
3519     if (SvPOK(*tv)) {
3520     (&arg2)->push_back(SvPVX(*tv));
3521     } else {
3522     SWIG_croak("Type error in argument 2 of "
3523     "Document_make_snippet. "
3524     "Expected an array of ""std::string");
3525     }
3526     }
3527     } else {
3528     SWIG_croak("Type error in argument 2 of Document_make_snippet. "
3529     "Expected an array of ""std::string");
3530     }
3531     }
3532     arg3 = (int) SvIV(ST(2));
3533     arg4 = (int) SvIV(ST(3));
3534     arg5 = (int) SvIV(ST(4));
3535     {
3536     try {
3537     result = (char *)(arg1)->make_snippet(arg2,arg3,arg4,arg5);
3538    
3539     } catch (const char *msg) {
3540     SWIG_exception(SWIG_RuntimeError, msg);
3541     }
3542     }
3543     ST(argvi) = sv_newmortal();
3544     if (result) {
3545     sv_setpv((SV*)ST(argvi++), (char *) result);
3546     } else {
3547     sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3548     }
3549     XSRETURN(argvi);
3550     fail:
3551     ;
3552     }
3553     croak(Nullch);
3554     }
3555    
3556    
3557     XS(_wrap_new_Database) {
3558     {
3559     estraier::Database *result;
3560     int argvi = 0;
3561     dXSARGS;
3562    
3563     if ((items < 0) || (items > 0)) {
3564     SWIG_croak("Usage: new_Database();");
3565     }
3566     {
3567     try {
3568     result = (estraier::Database *)new estraier::Database();
3569    
3570     } catch (const char *msg) {
3571     SWIG_exception(SWIG_RuntimeError, msg);
3572     }
3573     }
3574     ST(argvi) = sv_newmortal();
3575     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Database, SWIG_SHADOW|SWIG_OWNER);
3576     XSRETURN(argvi);
3577     fail:
3578     ;
3579     }
3580     croak(Nullch);
3581     }
3582    
3583    
3584     XS(_wrap_delete_Database) {
3585     {
3586     estraier::Database *arg1 = (estraier::Database *) 0 ;
3587     int argvi = 0;
3588     dXSARGS;
3589    
3590     if ((items < 1) || (items > 1)) {
3591     SWIG_croak("Usage: delete_Database(self);");
3592     }
3593     {
3594     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3595     SWIG_croak("Type error in argument 1 of delete_Database. Expected _p_estraier__Database");
3596     }
3597     }
3598     {
3599     try {
3600     delete arg1;
3601    
3602     } catch (const char *msg) {
3603     SWIG_exception(SWIG_RuntimeError, msg);
3604     }
3605     }
3606    
3607     XSRETURN(argvi);
3608     fail:
3609     ;
3610     }
3611     croak(Nullch);
3612     }
3613    
3614    
3615     XS(_wrap_Database_open) {
3616     {
3617     estraier::Database *arg1 = (estraier::Database *) 0 ;
3618     char *arg2 = (char *) 0 ;
3619     int arg3 ;
3620     bool result;
3621     int argvi = 0;
3622     dXSARGS;
3623    
3624     if ((items < 3) || (items > 3)) {
3625     SWIG_croak("Usage: Database_open(self,dbname,mode);");
3626     }
3627     {
3628     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3629     SWIG_croak("Type error in argument 1 of Database_open. Expected _p_estraier__Database");
3630     }
3631     }
3632     if (!SvOK((SV*) ST(1))) arg2 = 0;
3633     else arg2 = (char *) SvPV(ST(1), PL_na);
3634     arg3 = (int) SvIV(ST(2));
3635     {
3636     try {
3637     result = (bool)(arg1)->open((char const *)arg2,arg3);
3638    
3639     } catch (const char *msg) {
3640     SWIG_exception(SWIG_RuntimeError, msg);
3641     }
3642     }
3643     ST(argvi) = sv_newmortal();
3644     sv_setiv(ST(argvi++), (IV) result);
3645     XSRETURN(argvi);
3646     fail:
3647     ;
3648     }
3649     croak(Nullch);
3650     }
3651    
3652    
3653     XS(_wrap_Database_close) {
3654     {
3655     estraier::Database *arg1 = (estraier::Database *) 0 ;
3656     bool result;
3657     int argvi = 0;
3658     dXSARGS;
3659    
3660     if ((items < 1) || (items > 1)) {
3661     SWIG_croak("Usage: Database_close(self);");
3662     }
3663     {
3664     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3665     SWIG_croak("Type error in argument 1 of Database_close. Expected _p_estraier__Database");
3666     }
3667     }
3668     {
3669     try {
3670     result = (bool)(arg1)->close();
3671    
3672     } catch (const char *msg) {
3673     SWIG_exception(SWIG_RuntimeError, msg);
3674     }
3675     }
3676     ST(argvi) = sv_newmortal();
3677     sv_setiv(ST(argvi++), (IV) result);
3678     XSRETURN(argvi);
3679     fail:
3680     ;
3681     }
3682     croak(Nullch);
3683     }
3684    
3685    
3686     XS(_wrap_Database_put_doc) {
3687     {
3688     estraier::Database *arg1 = (estraier::Database *) 0 ;
3689     estraier::Document *arg2 = (estraier::Document *) 0 ;
3690     int arg3 ;
3691     bool result;
3692     int argvi = 0;
3693     dXSARGS;
3694    
3695     if ((items < 3) || (items > 3)) {
3696     SWIG_croak("Usage: Database_put_doc(self,doc,options);");
3697     }
3698     {
3699     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3700     SWIG_croak("Type error in argument 1 of Database_put_doc. Expected _p_estraier__Database");
3701     }
3702     }
3703     {
3704     if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_estraier__Document,0) < 0) {
3705     SWIG_croak("Type error in argument 2 of Database_put_doc. Expected _p_estraier__Document");
3706     }
3707     }
3708     arg3 = (int) SvIV(ST(2));
3709     {
3710     try {
3711     result = (bool)(arg1)->put_doc(arg2,arg3);
3712    
3713     } catch (const char *msg) {
3714     SWIG_exception(SWIG_RuntimeError, msg);
3715     }
3716     }
3717     ST(argvi) = sv_newmortal();
3718     sv_setiv(ST(argvi++), (IV) result);
3719     XSRETURN(argvi);
3720     fail:
3721     ;
3722     }
3723     croak(Nullch);
3724     }
3725    
3726    
3727     XS(_wrap_Database_search) {
3728     {
3729     estraier::Database *arg1 = (estraier::Database *) 0 ;
3730     estraier::Condition *arg2 = (estraier::Condition *) 0 ;
3731     int arg3 ;
3732     std::vector<int > *result;
3733     int argvi = 0;
3734     dXSARGS;
3735    
3736     if ((items < 3) || (items > 3)) {
3737     SWIG_croak("Usage: Database_search(self,cond,options);");
3738     }
3739     {
3740     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3741     SWIG_croak("Type error in argument 1 of Database_search. Expected _p_estraier__Database");
3742     }
3743     }
3744     {
3745     if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_estraier__Condition,0) < 0) {
3746     SWIG_croak("Type error in argument 2 of Database_search. Expected _p_estraier__Condition");
3747     }
3748     }
3749     arg3 = (int) SvIV(ST(2));
3750     {
3751     try {
3752     result = (std::vector<int > *)(arg1)->search(arg2,arg3);
3753    
3754     } catch (const char *msg) {
3755     SWIG_exception(SWIG_RuntimeError, msg);
3756     }
3757     }
3758     ST(argvi) = sv_newmortal();
3759     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__vectorTint_t, SWIG_SHADOW|0);
3760     XSRETURN(argvi);
3761     fail:
3762     ;
3763     }
3764     croak(Nullch);
3765     }
3766    
3767    
3768     XS(_wrap_Database_err_msg) {
3769     {
3770     int arg1 ;
3771     char *result;
3772     int argvi = 0;
3773     dXSARGS;
3774    
3775     if ((items < 1) || (items > 1)) {
3776     SWIG_croak("Usage: Database_err_msg(ecode);");
3777     }
3778     arg1 = (int) SvIV(ST(0));
3779     {
3780     try {
3781     result = (char *)estraier::Database::err_msg(arg1);
3782    
3783     } catch (const char *msg) {
3784     SWIG_exception(SWIG_RuntimeError, msg);
3785     }
3786     }
3787     ST(argvi) = sv_newmortal();
3788     if (result) {
3789     sv_setpv((SV*)ST(argvi++), (char *) result);
3790     } else {
3791     sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3792     }
3793     XSRETURN(argvi);
3794     fail:
3795     ;
3796     }
3797     croak(Nullch);
3798     }
3799    
3800    
3801     XS(_wrap_Database_error) {
3802     {
3803     estraier::Database *arg1 = (estraier::Database *) 0 ;
3804     int result;
3805     int argvi = 0;
3806     dXSARGS;
3807    
3808     if ((items < 1) || (items > 1)) {
3809     SWIG_croak("Usage: Database_error(self);");
3810     }
3811     {
3812     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3813     SWIG_croak("Type error in argument 1 of Database_error. Expected _p_estraier__Database");
3814     }
3815     }
3816     {
3817     try {
3818     result = (int)(arg1)->error();
3819    
3820     } catch (const char *msg) {
3821     SWIG_exception(SWIG_RuntimeError, msg);
3822     }
3823     }
3824     ST(argvi) = sv_newmortal();
3825     sv_setiv(ST(argvi++), (IV) result);
3826     XSRETURN(argvi);
3827     fail:
3828     ;
3829     }
3830     croak(Nullch);
3831     }
3832    
3833    
3834     XS(_wrap_Database_fatal) {
3835     {
3836     estraier::Database *arg1 = (estraier::Database *) 0 ;
3837     bool result;
3838     int argvi = 0;
3839     dXSARGS;
3840    
3841     if ((items < 1) || (items > 1)) {
3842     SWIG_croak("Usage: Database_fatal(self);");
3843     }
3844     {
3845     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3846     SWIG_croak("Type error in argument 1 of Database_fatal. Expected _p_estraier__Database");
3847     }
3848     }
3849     {
3850     try {
3851     result = (bool)(arg1)->fatal();
3852    
3853     } catch (const char *msg) {
3854     SWIG_exception(SWIG_RuntimeError, msg);
3855     }
3856     }
3857     ST(argvi) = sv_newmortal();
3858     sv_setiv(ST(argvi++), (IV) result);
3859     XSRETURN(argvi);
3860     fail:
3861     ;
3862     }
3863     croak(Nullch);
3864     }
3865    
3866    
3867     XS(_wrap_Database_flush) {
3868     {
3869     estraier::Database *arg1 = (estraier::Database *) 0 ;
3870     int arg2 ;
3871     bool result;
3872     int argvi = 0;
3873     dXSARGS;
3874    
3875     if ((items < 2) || (items > 2)) {
3876     SWIG_croak("Usage: Database_flush(self,_max);");
3877     }
3878     {
3879     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3880     SWIG_croak("Type error in argument 1 of Database_flush. Expected _p_estraier__Database");
3881     }
3882     }
3883     arg2 = (int) SvIV(ST(1));
3884     {
3885     try {
3886     result = (bool)(arg1)->flush(arg2);
3887    
3888     } catch (const char *msg) {
3889     SWIG_exception(SWIG_RuntimeError, msg);
3890     }
3891     }
3892     ST(argvi) = sv_newmortal();
3893     sv_setiv(ST(argvi++), (IV) result);
3894     XSRETURN(argvi);
3895     fail:
3896     ;
3897     }
3898     croak(Nullch);
3899     }
3900    
3901    
3902     XS(_wrap_Database_sync) {
3903     {
3904     estraier::Database *arg1 = (estraier::Database *) 0 ;
3905     bool result;
3906     int argvi = 0;
3907     dXSARGS;
3908    
3909     if ((items < 1) || (items > 1)) {
3910     SWIG_croak("Usage: Database_sync(self);");
3911     }
3912     {
3913     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3914     SWIG_croak("Type error in argument 1 of Database_sync. Expected _p_estraier__Database");
3915     }
3916     }
3917     {
3918     try {
3919     result = (bool)(arg1)->sync();
3920    
3921     } catch (const char *msg) {
3922     SWIG_exception(SWIG_RuntimeError, msg);
3923     }
3924     }
3925     ST(argvi) = sv_newmortal();
3926     sv_setiv(ST(argvi++), (IV) result);
3927     XSRETURN(argvi);
3928     fail:
3929     ;
3930     }
3931     croak(Nullch);
3932     }
3933    
3934    
3935     XS(_wrap_Database_optimize) {
3936     {
3937     estraier::Database *arg1 = (estraier::Database *) 0 ;
3938     int arg2 ;
3939     bool result;
3940     int argvi = 0;
3941     dXSARGS;
3942    
3943     if ((items < 2) || (items > 2)) {
3944     SWIG_croak("Usage: Database_optimize(self,options);");
3945     }
3946     {
3947     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3948     SWIG_croak("Type error in argument 1 of Database_optimize. Expected _p_estraier__Database");
3949     }
3950     }
3951     arg2 = (int) SvIV(ST(1));
3952     {
3953     try {
3954     result = (bool)(arg1)->optimize(arg2);
3955    
3956     } catch (const char *msg) {
3957     SWIG_exception(SWIG_RuntimeError, msg);
3958     }
3959     }
3960     ST(argvi) = sv_newmortal();
3961     sv_setiv(ST(argvi++), (IV) result);
3962     XSRETURN(argvi);
3963     fail:
3964     ;
3965     }
3966     croak(Nullch);
3967     }
3968    
3969    
3970     XS(_wrap_Database_out_doc) {
3971     {
3972     estraier::Database *arg1 = (estraier::Database *) 0 ;
3973     int arg2 ;
3974     int arg3 ;
3975     bool result;
3976     int argvi = 0;
3977     dXSARGS;
3978    
3979     if ((items < 3) || (items > 3)) {
3980     SWIG_croak("Usage: Database_out_doc(self,id,options);");
3981     }
3982     {
3983     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
3984     SWIG_croak("Type error in argument 1 of Database_out_doc. Expected _p_estraier__Database");
3985     }
3986     }
3987     arg2 = (int) SvIV(ST(1));
3988     arg3 = (int) SvIV(ST(2));
3989     {
3990     try {
3991     result = (bool)(arg1)->out_doc(arg2,arg3);
3992    
3993     } catch (const char *msg) {
3994     SWIG_exception(SWIG_RuntimeError, msg);
3995     }
3996     }
3997     ST(argvi) = sv_newmortal();
3998     sv_setiv(ST(argvi++), (IV) result);
3999     XSRETURN(argvi);
4000     fail:
4001     ;
4002     }
4003     croak(Nullch);
4004     }
4005    
4006    
4007     XS(_wrap_Database_get_doc) {
4008     {
4009     estraier::Database *arg1 = (estraier::Database *) 0 ;
4010     int arg2 ;
4011     int arg3 ;
4012     estraier::Document *result;
4013     int argvi = 0;
4014     dXSARGS;
4015    
4016     if ((items < 3) || (items > 3)) {
4017     SWIG_croak("Usage: Database_get_doc(self,id,options);");
4018     }
4019     {
4020     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4021     SWIG_croak("Type error in argument 1 of Database_get_doc. Expected _p_estraier__Database");
4022     }
4023     }
4024     arg2 = (int) SvIV(ST(1));
4025     arg3 = (int) SvIV(ST(2));
4026     {
4027     try {
4028     result = (estraier::Document *)(arg1)->get_doc(arg2,arg3);
4029    
4030     } catch (const char *msg) {
4031     SWIG_exception(SWIG_RuntimeError, msg);
4032     }
4033     }
4034     ST(argvi) = sv_newmortal();
4035     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_estraier__Document, SWIG_SHADOW|0);
4036     XSRETURN(argvi);
4037     fail:
4038     ;
4039     }
4040     croak(Nullch);
4041     }
4042    
4043    
4044     XS(_wrap_Database_uri_to_id) {
4045     {
4046     estraier::Database *arg1 = (estraier::Database *) 0 ;
4047     char *arg2 = (char *) 0 ;
4048     int result;
4049     int argvi = 0;
4050     dXSARGS;
4051    
4052     if ((items < 2) || (items > 2)) {
4053     SWIG_croak("Usage: Database_uri_to_id(self,uri);");
4054     }
4055     {
4056     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4057     SWIG_croak("Type error in argument 1 of Database_uri_to_id. Expected _p_estraier__Database");
4058     }
4059     }
4060     if (!SvOK((SV*) ST(1))) arg2 = 0;
4061     else arg2 = (char *) SvPV(ST(1), PL_na);
4062     {
4063     try {
4064     result = (int)(arg1)->uri_to_id((char const *)arg2);
4065    
4066     } catch (const char *msg) {
4067     SWIG_exception(SWIG_RuntimeError, msg);
4068     }
4069     }
4070     ST(argvi) = sv_newmortal();
4071     sv_setiv(ST(argvi++), (IV) result);
4072     XSRETURN(argvi);
4073     fail:
4074     ;
4075     }
4076     croak(Nullch);
4077     }
4078    
4079    
4080     XS(_wrap_Database_etch_doc) {
4081     {
4082     estraier::Database *arg1 = (estraier::Database *) 0 ;
4083     estraier::Document *arg2 = (estraier::Document *) 0 ;
4084     int arg3 ;
4085     std::map<std::string,std::string > *result;
4086     int argvi = 0;
4087     dXSARGS;
4088    
4089     if ((items < 3) || (items > 3)) {
4090     SWIG_croak("Usage: Database_etch_doc(self,doc,max);");
4091     }
4092     {
4093     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4094     SWIG_croak("Type error in argument 1 of Database_etch_doc. Expected _p_estraier__Database");
4095     }
4096     }
4097     {
4098     if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_estraier__Document,0) < 0) {
4099     SWIG_croak("Type error in argument 2 of Database_etch_doc. Expected _p_estraier__Document");
4100     }
4101     }
4102     arg3 = (int) SvIV(ST(2));
4103     {
4104     try {
4105     result = (std::map<std::string,std::string > *)(arg1)->etch_doc(arg2,arg3);
4106    
4107     } catch (const char *msg) {
4108     SWIG_exception(SWIG_RuntimeError, msg);
4109     }
4110     }
4111     ST(argvi) = sv_newmortal();
4112     SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, SWIG_SHADOW|0);
4113     XSRETURN(argvi);
4114     fail:
4115     ;
4116     }
4117     croak(Nullch);
4118     }
4119    
4120    
4121     XS(_wrap_Database_iter_init) {
4122     {
4123     estraier::Database *arg1 = (estraier::Database *) 0 ;
4124     bool result;
4125     int argvi = 0;
4126     dXSARGS;
4127    
4128     if ((items < 1) || (items > 1)) {
4129     SWIG_croak("Usage: Database_iter_init(self);");
4130     }
4131     {
4132     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4133     SWIG_croak("Type error in argument 1 of Database_iter_init. Expected _p_estraier__Database");
4134     }
4135     }
4136     {
4137     try {
4138     result = (bool)(arg1)->iter_init();
4139    
4140     } catch (const char *msg) {
4141     SWIG_exception(SWIG_RuntimeError, msg);
4142     }
4143     }
4144     ST(argvi) = sv_newmortal();
4145     sv_setiv(ST(argvi++), (IV) result);
4146     XSRETURN(argvi);
4147     fail:
4148     ;
4149     }
4150     croak(Nullch);
4151     }
4152    
4153    
4154     XS(_wrap_Database_iter_next) {
4155     {
4156     estraier::Database *arg1 = (estraier::Database *) 0 ;
4157     int result;
4158     int argvi = 0;
4159     dXSARGS;
4160    
4161     if ((items < 1) || (items > 1)) {
4162     SWIG_croak("Usage: Database_iter_next(self);");
4163     }
4164     {
4165     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4166     SWIG_croak("Type error in argument 1 of Database_iter_next. Expected _p_estraier__Database");
4167     }
4168     }
4169     {
4170     try {
4171     result = (int)(arg1)->iter_next();
4172    
4173     } catch (const char *msg) {
4174     SWIG_exception(SWIG_RuntimeError, msg);
4175     }
4176     }
4177     ST(argvi) = sv_newmortal();
4178     sv_setiv(ST(argvi++), (IV) result);
4179     XSRETURN(argvi);
4180     fail:
4181     ;
4182     }
4183     croak(Nullch);
4184     }
4185    
4186    
4187     XS(_wrap_Database_name) {
4188     {
4189     estraier::Database *arg1 = (estraier::Database *) 0 ;
4190     char *result;
4191     int argvi = 0;
4192     dXSARGS;
4193    
4194     if ((items < 1) || (items > 1)) {
4195     SWIG_croak("Usage: Database_name(self);");
4196     }
4197     {
4198     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4199     SWIG_croak("Type error in argument 1 of Database_name. Expected _p_estraier__Database");
4200     }
4201     }
4202     {
4203     try {
4204     result = (char *)(arg1)->name();
4205    
4206     } catch (const char *msg) {
4207     SWIG_exception(SWIG_RuntimeError, msg);
4208     }
4209     }
4210     ST(argvi) = sv_newmortal();
4211     if (result) {
4212     sv_setpv((SV*)ST(argvi++), (char *) result);
4213     } else {
4214     sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
4215     }
4216     XSRETURN(argvi);
4217     fail:
4218     ;
4219     }
4220     croak(Nullch);
4221     }
4222    
4223    
4224     XS(_wrap_Database_doc_num) {
4225     {
4226     estraier::Database *arg1 = (estraier::Database *) 0 ;
4227     int result;
4228     int argvi = 0;
4229     dXSARGS;
4230    
4231     if ((items < 1) || (items > 1)) {
4232     SWIG_croak("Usage: Database_doc_num(self);");
4233     }
4234     {
4235     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4236     SWIG_croak("Type error in argument 1 of Database_doc_num. Expected _p_estraier__Database");
4237     }
4238     }
4239     {
4240     try {
4241     result = (int)(arg1)->doc_num();
4242    
4243     } catch (const char *msg) {
4244     SWIG_exception(SWIG_RuntimeError, msg);
4245     }
4246     }
4247     ST(argvi) = sv_newmortal();
4248     sv_setiv(ST(argvi++), (IV) result);
4249     XSRETURN(argvi);
4250     fail:
4251     ;
4252     }
4253     croak(Nullch);
4254     }
4255    
4256    
4257     XS(_wrap_Database_word_num) {
4258     {
4259     estraier::Database *arg1 = (estraier::Database *) 0 ;
4260     int result;
4261     int argvi = 0;
4262     dXSARGS;
4263    
4264     if ((items < 1) || (items > 1)) {
4265     SWIG_croak("Usage: Database_word_num(self);");
4266     }
4267     {
4268     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4269     SWIG_croak("Type error in argument 1 of Database_word_num. Expected _p_estraier__Database");
4270     }
4271     }
4272     {
4273     try {
4274     result = (int)(arg1)->word_num();
4275    
4276     } catch (const char *msg) {
4277     SWIG_exception(SWIG_RuntimeError, msg);
4278     }
4279     }
4280     ST(argvi) = sv_newmortal();
4281     sv_setiv(ST(argvi++), (IV) result);
4282     XSRETURN(argvi);
4283     fail:
4284     ;
4285     }
4286     croak(Nullch);
4287     }
4288    
4289    
4290     XS(_wrap_Database_size) {
4291     {
4292     estraier::Database *arg1 = (estraier::Database *) 0 ;
4293     double result;
4294     int argvi = 0;
4295     dXSARGS;
4296    
4297     if ((items < 1) || (items > 1)) {
4298     SWIG_croak("Usage: Database_size(self);");
4299     }
4300     {
4301     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4302     SWIG_croak("Type error in argument 1 of Database_size. Expected _p_estraier__Database");
4303     }
4304     }
4305     {
4306     try {
4307     result = (double)(arg1)->size();
4308    
4309     } catch (const char *msg) {
4310     SWIG_exception(SWIG_RuntimeError, msg);
4311     }
4312     }
4313     ST(argvi) = sv_newmortal();
4314     sv_setnv(ST(argvi++), (double) result);
4315     XSRETURN(argvi);
4316     fail:
4317     ;
4318     }
4319     croak(Nullch);
4320     }
4321    
4322    
4323     XS(_wrap_Database_set_cache_size) {
4324     {
4325     estraier::Database *arg1 = (estraier::Database *) 0 ;
4326     size_t arg2 ;
4327     int arg3 ;
4328     int arg4 ;
4329     int argvi = 0;
4330     dXSARGS;
4331    
4332     if ((items < 4) || (items > 4)) {
4333     SWIG_croak("Usage: Database_set_cache_size(self,size,anum,tnum);");
4334     }
4335     {
4336     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4337     SWIG_croak("Type error in argument 1 of Database_set_cache_size. Expected _p_estraier__Database");
4338     }
4339     }
4340     arg2 = (size_t) SvUV(ST(1));
4341     arg3 = (int) SvIV(ST(2));
4342     arg4 = (int) SvIV(ST(3));
4343     {
4344     try {
4345     (arg1)->set_cache_size(arg2,arg3,arg4);
4346    
4347     } catch (const char *msg) {
4348     SWIG_exception(SWIG_RuntimeError, msg);
4349     }
4350     }
4351    
4352     XSRETURN(argvi);
4353     fail:
4354     ;
4355     }
4356     croak(Nullch);
4357     }
4358    
4359    
4360     XS(_wrap_Database_set_special_cache) {
4361     {
4362     estraier::Database *arg1 = (estraier::Database *) 0 ;
4363     char *arg2 = (char *) 0 ;
4364     int arg3 ;
4365     int argvi = 0;
4366     dXSARGS;
4367    
4368     if ((items < 3) || (items > 3)) {
4369     SWIG_croak("Usage: Database_set_special_cache(self,name,num);");
4370     }
4371     {
4372     if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_estraier__Database,0) < 0) {
4373     SWIG_croak("Type error in argument 1 of Database_set_special_cache. Expected _p_estraier__Database");
4374     }
4375     }
4376     if (!SvOK((SV*) ST(1))) arg2 = 0;
4377     else arg2 = (char *) SvPV(ST(1), PL_na);
4378     arg3 = (int) SvIV(ST(2));
4379     {
4380     try {
4381     (arg1)->set_special_cache((char const *)arg2,arg3);
4382    
4383     } catch (const char *msg) {
4384     SWIG_exception(SWIG_RuntimeError, msg);
4385     }
4386     }
4387    
4388     XSRETURN(argvi);
4389     fail:
4390     ;
4391     }
4392     croak(Nullch);
4393     }
4394    
4395    
4396    
4397     /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4398    
4399     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}};
4400     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}};
4401     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}};
4402     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}};
4403     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}};
4404     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}};
4405     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}};
4406     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}};
4407     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}};
4408     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}};
4409    
4410     static swig_type_info *swig_types_initial[] = {
4411     _swigt__p_estraier__Condition,
4412     _swigt__p_ESTCOND,
4413     _swigt__p_estraier__Database,
4414     _swigt__p_ESTDOC,
4415     _swigt__p_std__vectorTstd__string_t,
4416     _swigt__p_std__mapTstd__string_std__string_t,
4417     _swigt__p_std__vectorTint_t,
4418     _swigt__p_std__string,
4419     _swigt__p_estraier__Document,
4420     _swigt__p_size_t,
4421     0
4422     };
4423    
4424    
4425     /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4426    
4427     static swig_constant_info swig_constants[] = {
4428     { SWIG_INT, (char *) SWIG_prefix "Condition_SURE", (long) estraier::Condition::SURE, 0, 0, 0},
4429     { SWIG_INT, (char *) SWIG_prefix "Condition_USUAL", (long) estraier::Condition::USUAL, 0, 0, 0},
4430     { SWIG_INT, (char *) SWIG_prefix "Condition_FAST", (long) estraier::Condition::FAST, 0, 0, 0},
4431     { SWIG_INT, (char *) SWIG_prefix "Condition_AGITO", (long) estraier::Condition::AGITO, 0, 0, 0},
4432     { SWIG_INT, (char *) SWIG_prefix "Condition_NOIDF", (long) estraier::Condition::NOIDF, 0, 0, 0},
4433     { SWIG_INT, (char *) SWIG_prefix "Condition_SIMPLE", (long) estraier::Condition::SIMPLE, 0, 0, 0},
4434     { SWIG_INT, (char *) SWIG_prefix "Database_ERRNOERR", (long) estraier::Database::ERRNOERR, 0, 0, 0},
4435     { SWIG_INT, (char *) SWIG_prefix "Database_ERRINVAL", (long) estraier::Database::ERRINVAL, 0, 0, 0},
4436     { SWIG_INT, (char *) SWIG_prefix "Database_ERRACCES", (long) estraier::Database::ERRACCES, 0, 0, 0},
4437     { SWIG_INT, (char *) SWIG_prefix "Database_ERRLOCK", (long) estraier::Database::ERRLOCK, 0, 0, 0},
4438     { SWIG_INT, (char *) SWIG_prefix "Database_ERRDB", (long) estraier::Database::ERRDB, 0, 0, 0},
4439     { SWIG_INT, (char *) SWIG_prefix "Database_ERRIO", (long) estraier::Database::ERRIO, 0, 0, 0},
4440     { SWIG_INT, (char *) SWIG_prefix "Database_ERRNOITEM", (long) estraier::Database::ERRNOITEM, 0, 0, 0},
4441     { SWIG_INT, (char *) SWIG_prefix "Database_ERRMISC", (long) estraier::Database::ERRMISC, 0, 0, 0},
4442     { SWIG_INT, (char *) SWIG_prefix "Database_DBREADER", (long) estraier::Database::DBREADER, 0, 0, 0},
4443     { SWIG_INT, (char *) SWIG_prefix "Database_DBWRITER", (long) estraier::Database::DBWRITER, 0, 0, 0},
4444     { SWIG_INT, (char *) SWIG_prefix "Database_DBCREAT", (long) estraier::Database::DBCREAT, 0, 0, 0},
4445     { SWIG_INT, (char *) SWIG_prefix "Database_DBTRUNC", (long) estraier::Database::DBTRUNC, 0, 0, 0},
4446     { SWIG_INT, (char *) SWIG_prefix "Database_DBNOLCK", (long) estraier::Database::DBNOLCK, 0, 0, 0},
4447     { SWIG_INT, (char *) SWIG_prefix "Database_DBLCKNB", (long) estraier::Database::DBLCKNB, 0, 0, 0},
4448     { SWIG_INT, (char *) SWIG_prefix "Database_DBPERFNG", (long) estraier::Database::DBPERFNG, 0, 0, 0},
4449     { SWIG_INT, (char *) SWIG_prefix "Database_PDCLEAN", (long) estraier::Database::PDCLEAN, 0, 0, 0},
4450     { SWIG_INT, (char *) SWIG_prefix "Database_ODCLEAN", (long) estraier::Database::ODCLEAN, 0, 0, 0},
4451     { SWIG_INT, (char *) SWIG_prefix "Database_OPTNOPURGE", (long) estraier::Database::OPTNOPURGE, 0, 0, 0},
4452     { SWIG_INT, (char *) SWIG_prefix "Database_OPTNODBOPT", (long) estraier::Database::OPTNODBOPT, 0, 0, 0},
4453     { SWIG_INT, (char *) SWIG_prefix "Database_GDNOATTR", (long) estraier::Database::GDNOATTR, 0, 0, 0},
4454     { SWIG_INT, (char *) SWIG_prefix "Database_GDNOTEXT", (long) estraier::Database::GDNOTEXT, 0, 0, 0},
4455     {0,0,0,0,0,0}
4456     };
4457     #ifdef __cplusplus
4458     }
4459     #endif
4460     static swig_variable_info swig_variables[] = {
4461     {0,0,0,0}
4462     };
4463     static swig_command_info swig_commands[] = {
4464     {"HyperEstraierc::new_StrVector", _wrap_new_StrVector},
4465     {"HyperEstraierc::StrVector_size", _wrap_StrVector_size},
4466     {"HyperEstraierc::StrVector_empty", _wrap_StrVector_empty},
4467     {"HyperEstraierc::StrVector_clear", _wrap_StrVector_clear},
4468     {"HyperEstraierc::StrVector_push", _wrap_StrVector_push},
4469     {"HyperEstraierc::StrVector_pop", _wrap_StrVector_pop},
4470     {"HyperEstraierc::StrVector_get", _wrap_StrVector_get},
4471     {"HyperEstraierc::StrVector_set", _wrap_StrVector_set},
4472     {"HyperEstraierc::delete_StrVector", _wrap_delete_StrVector},
4473     {"HyperEstraierc::new_IntVector", _wrap_new_IntVector},
4474     {"HyperEstraierc::IntVector_size", _wrap_IntVector_size},
4475     {"HyperEstraierc::IntVector_empty", _wrap_IntVector_empty},
4476     {"HyperEstraierc::IntVector_clear", _wrap_IntVector_clear},
4477     {"HyperEstraierc::IntVector_push", _wrap_IntVector_push},
4478     {"HyperEstraierc::IntVector_pop", _wrap_IntVector_pop},
4479     {"HyperEstraierc::IntVector_get", _wrap_IntVector_get},
4480     {"HyperEstraierc::IntVector_set", _wrap_IntVector_set},
4481     {"HyperEstraierc::delete_IntVector", _wrap_delete_IntVector},
4482     {"HyperEstraierc::new_StrStrMap", _wrap_new_StrStrMap},
4483     {"HyperEstraierc::StrStrMap_size", _wrap_StrStrMap_size},
4484     {"HyperEstraierc::StrStrMap_empty", _wrap_StrStrMap_empty},
4485     {"HyperEstraierc::StrStrMap_clear", _wrap_StrStrMap_clear},
4486     {"HyperEstraierc::StrStrMap_get", _wrap_StrStrMap_get},
4487     {"HyperEstraierc::StrStrMap_set", _wrap_StrStrMap_set},
4488     {"HyperEstraierc::StrStrMap_del", _wrap_StrStrMap_del},
4489     {"HyperEstraierc::StrStrMap_has_key", _wrap_StrStrMap_has_key},
4490     {"HyperEstraierc::delete_StrStrMap", _wrap_delete_StrStrMap},
4491     {"HyperEstraierc::Condition_cond_set", _wrap_Condition_cond_set},
4492     {"HyperEstraierc::Condition_cond_get", _wrap_Condition_cond_get},
4493     {"HyperEstraierc::new_Condition", _wrap_new_Condition},
4494     {"HyperEstraierc::delete_Condition", _wrap_delete_Condition},
4495     {"HyperEstraierc::Condition_set_phrase", _wrap_Condition_set_phrase},
4496     {"HyperEstraierc::Condition_add_attr", _wrap_Condition_add_attr},
4497     {"HyperEstraierc::Condition_set_order", _wrap_Condition_set_order},
4498     {"HyperEstraierc::Condition_set_max", _wrap_Condition_set_max},
4499     {"HyperEstraierc::Condition_set_options", _wrap_Condition_set_options},
4500     {"HyperEstraierc::Document_doc_set", _wrap_Document_doc_set},
4501     {"HyperEstraierc::Document_doc_get", _wrap_Document_doc_get},
4502     {"HyperEstraierc::new_Document", _wrap_new_Document},
4503     {"HyperEstraierc::delete_Document", _wrap_delete_Document},
4504     {"HyperEstraierc::Document_add_attr", _wrap_Document_add_attr},
4505     {"HyperEstraierc::Document_add_text", _wrap_Document_add_text},
4506     {"HyperEstraierc::Document_add_hidden_text", _wrap_Document_add_hidden_text},
4507     {"HyperEstraierc::Document_id", _wrap_Document_id},
4508     {"HyperEstraierc::Document_attr_names", _wrap_Document_attr_names},
4509     {"HyperEstraierc::Document_attr", _wrap_Document_attr},
4510     {"HyperEstraierc::Document_cat_texts", _wrap_Document_cat_texts},
4511     {"HyperEstraierc::Document_texts", _wrap_Document_texts},
4512     {"HyperEstraierc::Document_dump_draft", _wrap_Document_dump_draft},
4513     {"HyperEstraierc::Document_make_snippet", _wrap_Document_make_snippet},
4514     {"HyperEstraierc::new_Database", _wrap_new_Database},
4515     {"HyperEstraierc::delete_Database", _wrap_delete_Database},
4516     {"HyperEstraierc::Database_open", _wrap_Database_open},
4517     {"HyperEstraierc::Database_close", _wrap_Database_close},
4518     {"HyperEstraierc::Database_put_doc", _wrap_Database_put_doc},
4519     {"HyperEstraierc::Database_search", _wrap_Database_search},
4520     {"HyperEstraierc::Database_err_msg", _wrap_Database_err_msg},
4521     {"HyperEstraierc::Database_error", _wrap_Database_error},
4522     {"HyperEstraierc::Database_fatal", _wrap_Database_fatal},
4523     {"HyperEstraierc::Database_flush", _wrap_Database_flush},
4524     {"HyperEstraierc::Database_sync", _wrap_Database_sync},
4525     {"HyperEstraierc::Database_optimize", _wrap_Database_optimize},
4526     {"HyperEstraierc::Database_out_doc", _wrap_Database_out_doc},
4527     {"HyperEstraierc::Database_get_doc", _wrap_Database_get_doc},
4528     {"HyperEstraierc::Database_uri_to_id", _wrap_Database_uri_to_id},
4529     {"HyperEstraierc::Database_etch_doc", _wrap_Database_etch_doc},
4530     {"HyperEstraierc::Database_iter_init", _wrap_Database_iter_init},
4531     {"HyperEstraierc::Database_iter_next", _wrap_Database_iter_next},
4532     {"HyperEstraierc::Database_name", _wrap_Database_name},
4533     {"HyperEstraierc::Database_doc_num", _wrap_Database_doc_num},
4534     {"HyperEstraierc::Database_word_num", _wrap_Database_word_num},
4535     {"HyperEstraierc::Database_size", _wrap_Database_size},
4536     {"HyperEstraierc::Database_set_cache_size", _wrap_Database_set_cache_size},
4537     {"HyperEstraierc::Database_set_special_cache", _wrap_Database_set_special_cache},
4538     {0,0}
4539     };
4540    
4541    
4542     static void SWIG_Perl_SetTypeListHandle(swig_type_info **handle) {
4543     SV *pointer;
4544    
4545     /* create a new pointer */
4546     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
4547     sv_setiv(pointer, PTR2IV(swig_type_list_handle));
4548     }
4549    
4550     static swig_type_info **
4551     SWIG_Perl_LookupTypePointer(swig_type_info **type_list_handle) {
4552     swig_type_info **type_pointer;
4553    
4554     /* first check if module already created */
4555     type_pointer = SWIG_Perl_GetTypeListHandle();
4556     if (type_pointer) {
4557     return type_pointer;
4558     } else {
4559     /* create a new module and variable */
4560     SWIG_Perl_SetTypeListHandle(type_list_handle);
4561     return type_list_handle;
4562     }
4563     }
4564    
4565    
4566     #ifdef __cplusplus
4567     extern "C"
4568     #endif
4569    
4570     XS(SWIG_init) {
4571     dXSARGS;
4572     int i;
4573     static int _init = 0;
4574     if (!_init) {
4575     swig_type_list_handle = SWIG_Perl_LookupTypePointer(swig_type_list_handle);
4576     for (i = 0; swig_types_initial[i]; i++) {
4577     swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
4578     }
4579     _init = 1;
4580     }
4581    
4582     /* Install commands */
4583     for (i = 0; swig_commands[i].name; i++) {
4584     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4585     }
4586    
4587     /* Install variables */
4588     for (i = 0; swig_variables[i].name; i++) {
4589     SV *sv;
4590     sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
4591     if (swig_variables[i].type) {
4592     SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4593     } else {
4594     sv_setiv(sv,(IV) 0);
4595     }
4596     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4597     }
4598    
4599     /* Install constant */
4600     for (i = 0; swig_constants[i].type; i++) {
4601     SV *sv;
4602     sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
4603     switch(swig_constants[i].type) {
4604     case SWIG_INT:
4605     sv_setiv(sv, (IV) swig_constants[i].lvalue);
4606     break;
4607     case SWIG_FLOAT:
4608     sv_setnv(sv, (double) swig_constants[i].dvalue);
4609     break;
4610     case SWIG_STRING:
4611     sv_setpv(sv, (char *) swig_constants[i].pvalue);
4612     break;
4613     case SWIG_POINTER:
4614     SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4615     break;
4616     case SWIG_BINARY:
4617     SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4618     break;
4619     default:
4620     break;
4621     }
4622     SvREADONLY_on(sv);
4623     }
4624    
4625     SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, (void*) "HyperEstraier::StrVector");
4626     SWIG_TypeClientData(SWIGTYPE_p_std__vectorTint_t, (void*) "HyperEstraier::IntVector");
4627     SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, (void*) "HyperEstraier::StrStrMap");
4628     SWIG_TypeClientData(SWIGTYPE_p_estraier__Condition, (void*) "HyperEstraier::Condition");
4629     SWIG_TypeClientData(SWIGTYPE_p_estraier__Document, (void*) "HyperEstraier::Document");
4630     SWIG_TypeClientData(SWIGTYPE_p_estraier__Database, (void*) "HyperEstraier::Database");
4631     ST(0) = &PL_sv_yes;
4632     XSRETURN(1);
4633     }
4634    

  ViewVC Help
Powered by ViewVC 1.1.26