/[hyperestraier_wrappers]/0.0.13/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.13/perl/HyperEstraier_wrap.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 14 - (hide annotations)
Fri Sep 9 15:26:39 2005 UTC (16 years, 1 month ago) by dpavlin
File size: 135785 byte(s)
import of 0.0.13
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 **)